deepfish-ai 2.0.2 → 2.0.3

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -29,6 +30,2801 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/js-yaml/lib/common.js
+var require_common = __commonJS({
+  "node_modules/js-yaml/lib/common.js"(exports2, module2) {
+    "use strict";
+    function isNothing(subject) {
+      return typeof subject === "undefined" || subject === null;
+    }
+    function isObject2(subject) {
+      return typeof subject === "object" && subject !== null;
+    }
+    function toArray(sequence) {
+      if (Array.isArray(sequence)) return sequence;
+      else if (isNothing(sequence)) return [];
+      return [sequence];
+    }
+    function extend2(target, source) {
+      var index, length, key, sourceKeys;
+      if (source) {
+        sourceKeys = Object.keys(source);
+        for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+          key = sourceKeys[index];
+          target[key] = source[key];
+        }
+      }
+      return target;
+    }
+    function repeat(string4, count) {
+      var result = "", cycle;
+      for (cycle = 0; cycle < count; cycle += 1) {
+        result += string4;
+      }
+      return result;
+    }
+    function isNegativeZero(number4) {
+      return number4 === 0 && Number.NEGATIVE_INFINITY === 1 / number4;
+    }
+    module2.exports.isNothing = isNothing;
+    module2.exports.isObject = isObject2;
+    module2.exports.toArray = toArray;
+    module2.exports.repeat = repeat;
+    module2.exports.isNegativeZero = isNegativeZero;
+    module2.exports.extend = extend2;
+  }
+});
+
+// node_modules/js-yaml/lib/exception.js
+var require_exception = __commonJS({
+  "node_modules/js-yaml/lib/exception.js"(exports2, module2) {
+    "use strict";
+    function formatError2(exception, compact) {
+      var where = "", message = exception.reason || "(unknown reason)";
+      if (!exception.mark) return message;
+      if (exception.mark.name) {
+        where += 'in "' + exception.mark.name + '" ';
+      }
+      where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
+      if (!compact && exception.mark.snippet) {
+        where += "\n\n" + exception.mark.snippet;
+      }
+      return message + " " + where;
+    }
+    function YAMLException(reason, mark) {
+      Error.call(this);
+      this.name = "YAMLException";
+      this.reason = reason;
+      this.mark = mark;
+      this.message = formatError2(this, false);
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      } else {
+        this.stack = new Error().stack || "";
+      }
+    }
+    YAMLException.prototype = Object.create(Error.prototype);
+    YAMLException.prototype.constructor = YAMLException;
+    YAMLException.prototype.toString = function toString(compact) {
+      return this.name + ": " + formatError2(this, compact);
+    };
+    module2.exports = YAMLException;
+  }
+});
+
+// node_modules/js-yaml/lib/snippet.js
+var require_snippet = __commonJS({
+  "node_modules/js-yaml/lib/snippet.js"(exports2, module2) {
+    "use strict";
+    var common = require_common();
+    function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+      var head = "";
+      var tail = "";
+      var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+      if (position - lineStart > maxHalfLength) {
+        head = " ... ";
+        lineStart = position - maxHalfLength + head.length;
+      }
+      if (lineEnd - position > maxHalfLength) {
+        tail = " ...";
+        lineEnd = position + maxHalfLength - tail.length;
+      }
+      return {
+        str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail,
+        pos: position - lineStart + head.length
+        // relative position
+      };
+    }
+    function padStart(string4, max) {
+      return common.repeat(" ", max - string4.length) + string4;
+    }
+    function makeSnippet(mark, options) {
+      options = Object.create(options || null);
+      if (!mark.buffer) return null;
+      if (!options.maxLength) options.maxLength = 79;
+      if (typeof options.indent !== "number") options.indent = 1;
+      if (typeof options.linesBefore !== "number") options.linesBefore = 3;
+      if (typeof options.linesAfter !== "number") options.linesAfter = 2;
+      var re = /\r?\n|\r|\0/g;
+      var lineStarts = [0];
+      var lineEnds = [];
+      var match;
+      var foundLineNo = -1;
+      while (match = re.exec(mark.buffer)) {
+        lineEnds.push(match.index);
+        lineStarts.push(match.index + match[0].length);
+        if (mark.position <= match.index && foundLineNo < 0) {
+          foundLineNo = lineStarts.length - 2;
+        }
+      }
+      if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+      var result = "", i, line;
+      var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+      var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+      for (i = 1; i <= options.linesBefore; i++) {
+        if (foundLineNo - i < 0) break;
+        line = getLine(
+          mark.buffer,
+          lineStarts[foundLineNo - i],
+          lineEnds[foundLineNo - i],
+          mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
+          maxLineLength
+        );
+        result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
+      }
+      line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+      result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+      result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
+      for (i = 1; i <= options.linesAfter; i++) {
+        if (foundLineNo + i >= lineEnds.length) break;
+        line = getLine(
+          mark.buffer,
+          lineStarts[foundLineNo + i],
+          lineEnds[foundLineNo + i],
+          mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
+          maxLineLength
+        );
+        result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+      }
+      return result.replace(/\n$/, "");
+    }
+    module2.exports = makeSnippet;
+  }
+});
+
+// node_modules/js-yaml/lib/type.js
+var require_type = __commonJS({
+  "node_modules/js-yaml/lib/type.js"(exports2, module2) {
+    "use strict";
+    var YAMLException = require_exception();
+    var TYPE_CONSTRUCTOR_OPTIONS = [
+      "kind",
+      "multi",
+      "resolve",
+      "construct",
+      "instanceOf",
+      "predicate",
+      "represent",
+      "representName",
+      "defaultStyle",
+      "styleAliases"
+    ];
+    var YAML_NODE_KINDS = [
+      "scalar",
+      "sequence",
+      "mapping"
+    ];
+    function compileStyleAliases(map2) {
+      var result = {};
+      if (map2 !== null) {
+        Object.keys(map2).forEach(function(style) {
+          map2[style].forEach(function(alias) {
+            result[String(alias)] = style;
+          });
+        });
+      }
+      return result;
+    }
+    function Type(tag, options) {
+      options = options || {};
+      Object.keys(options).forEach(function(name) {
+        if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+          throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+        }
+      });
+      this.options = options;
+      this.tag = tag;
+      this.kind = options["kind"] || null;
+      this.resolve = options["resolve"] || function() {
+        return true;
+      };
+      this.construct = options["construct"] || function(data) {
+        return data;
+      };
+      this.instanceOf = options["instanceOf"] || null;
+      this.predicate = options["predicate"] || null;
+      this.represent = options["represent"] || null;
+      this.representName = options["representName"] || null;
+      this.defaultStyle = options["defaultStyle"] || null;
+      this.multi = options["multi"] || false;
+      this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
+      if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+        throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+      }
+    }
+    module2.exports = Type;
+  }
+});
+
+// node_modules/js-yaml/lib/schema.js
+var require_schema = __commonJS({
+  "node_modules/js-yaml/lib/schema.js"(exports2, module2) {
+    "use strict";
+    var YAMLException = require_exception();
+    var Type = require_type();
+    function compileList(schema, name) {
+      var result = [];
+      schema[name].forEach(function(currentType) {
+        var newIndex = result.length;
+        result.forEach(function(previousType, previousIndex) {
+          if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
+            newIndex = previousIndex;
+          }
+        });
+        result[newIndex] = currentType;
+      });
+      return result;
+    }
+    function compileMap() {
+      var result = {
+        scalar: {},
+        sequence: {},
+        mapping: {},
+        fallback: {},
+        multi: {
+          scalar: [],
+          sequence: [],
+          mapping: [],
+          fallback: []
+        }
+      }, index, length;
+      function collectType(type) {
+        if (type.multi) {
+          result.multi[type.kind].push(type);
+          result.multi["fallback"].push(type);
+        } else {
+          result[type.kind][type.tag] = result["fallback"][type.tag] = type;
+        }
+      }
+      for (index = 0, length = arguments.length; index < length; index += 1) {
+        arguments[index].forEach(collectType);
+      }
+      return result;
+    }
+    function Schema(definition) {
+      return this.extend(definition);
+    }
+    Schema.prototype.extend = function extend2(definition) {
+      var implicit = [];
+      var explicit = [];
+      if (definition instanceof Type) {
+        explicit.push(definition);
+      } else if (Array.isArray(definition)) {
+        explicit = explicit.concat(definition);
+      } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+        if (definition.implicit) implicit = implicit.concat(definition.implicit);
+        if (definition.explicit) explicit = explicit.concat(definition.explicit);
+      } else {
+        throw new YAMLException("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+      }
+      implicit.forEach(function(type) {
+        if (!(type instanceof Type)) {
+          throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+        }
+        if (type.loadKind && type.loadKind !== "scalar") {
+          throw new YAMLException("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+        }
+        if (type.multi) {
+          throw new YAMLException("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+        }
+      });
+      explicit.forEach(function(type) {
+        if (!(type instanceof Type)) {
+          throw new YAMLException("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+        }
+      });
+      var result = Object.create(Schema.prototype);
+      result.implicit = (this.implicit || []).concat(implicit);
+      result.explicit = (this.explicit || []).concat(explicit);
+      result.compiledImplicit = compileList(result, "implicit");
+      result.compiledExplicit = compileList(result, "explicit");
+      result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+      return result;
+    };
+    module2.exports = Schema;
+  }
+});
+
+// node_modules/js-yaml/lib/type/str.js
+var require_str = __commonJS({
+  "node_modules/js-yaml/lib/type/str.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    module2.exports = new Type("tag:yaml.org,2002:str", {
+      kind: "scalar",
+      construct: function(data) {
+        return data !== null ? data : "";
+      }
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/seq.js
+var require_seq = __commonJS({
+  "node_modules/js-yaml/lib/type/seq.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    module2.exports = new Type("tag:yaml.org,2002:seq", {
+      kind: "sequence",
+      construct: function(data) {
+        return data !== null ? data : [];
+      }
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/map.js
+var require_map = __commonJS({
+  "node_modules/js-yaml/lib/type/map.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    module2.exports = new Type("tag:yaml.org,2002:map", {
+      kind: "mapping",
+      construct: function(data) {
+        return data !== null ? data : {};
+      }
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/schema/failsafe.js
+var require_failsafe = __commonJS({
+  "node_modules/js-yaml/lib/schema/failsafe.js"(exports2, module2) {
+    "use strict";
+    var Schema = require_schema();
+    module2.exports = new Schema({
+      explicit: [
+        require_str(),
+        require_seq(),
+        require_map()
+      ]
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/null.js
+var require_null = __commonJS({
+  "node_modules/js-yaml/lib/type/null.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    function resolveYamlNull(data) {
+      if (data === null) return true;
+      var max = data.length;
+      return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
+    }
+    function constructYamlNull() {
+      return null;
+    }
+    function isNull(object2) {
+      return object2 === null;
+    }
+    module2.exports = new Type("tag:yaml.org,2002:null", {
+      kind: "scalar",
+      resolve: resolveYamlNull,
+      construct: constructYamlNull,
+      predicate: isNull,
+      represent: {
+        canonical: function() {
+          return "~";
+        },
+        lowercase: function() {
+          return "null";
+        },
+        uppercase: function() {
+          return "NULL";
+        },
+        camelcase: function() {
+          return "Null";
+        },
+        empty: function() {
+          return "";
+        }
+      },
+      defaultStyle: "lowercase"
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/bool.js
+var require_bool = __commonJS({
+  "node_modules/js-yaml/lib/type/bool.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    function resolveYamlBoolean(data) {
+      if (data === null) return false;
+      var max = data.length;
+      return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+    }
+    function constructYamlBoolean(data) {
+      return data === "true" || data === "True" || data === "TRUE";
+    }
+    function isBoolean(object2) {
+      return Object.prototype.toString.call(object2) === "[object Boolean]";
+    }
+    module2.exports = new Type("tag:yaml.org,2002:bool", {
+      kind: "scalar",
+      resolve: resolveYamlBoolean,
+      construct: constructYamlBoolean,
+      predicate: isBoolean,
+      represent: {
+        lowercase: function(object2) {
+          return object2 ? "true" : "false";
+        },
+        uppercase: function(object2) {
+          return object2 ? "TRUE" : "FALSE";
+        },
+        camelcase: function(object2) {
+          return object2 ? "True" : "False";
+        }
+      },
+      defaultStyle: "lowercase"
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/int.js
+var require_int = __commonJS({
+  "node_modules/js-yaml/lib/type/int.js"(exports2, module2) {
+    "use strict";
+    var common = require_common();
+    var Type = require_type();
+    function isHexCode(c) {
+      return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
+    }
+    function isOctCode(c) {
+      return 48 <= c && c <= 55;
+    }
+    function isDecCode(c) {
+      return 48 <= c && c <= 57;
+    }
+    function resolveYamlInteger(data) {
+      if (data === null) return false;
+      var max = data.length, index = 0, hasDigits = false, ch;
+      if (!max) return false;
+      ch = data[index];
+      if (ch === "-" || ch === "+") {
+        ch = data[++index];
+      }
+      if (ch === "0") {
+        if (index + 1 === max) return true;
+        ch = data[++index];
+        if (ch === "b") {
+          index++;
+          for (; index < max; index++) {
+            ch = data[index];
+            if (ch === "_") continue;
+            if (ch !== "0" && ch !== "1") return false;
+            hasDigits = true;
+          }
+          return hasDigits && ch !== "_";
+        }
+        if (ch === "x") {
+          index++;
+          for (; index < max; index++) {
+            ch = data[index];
+            if (ch === "_") continue;
+            if (!isHexCode(data.charCodeAt(index))) return false;
+            hasDigits = true;
+          }
+          return hasDigits && ch !== "_";
+        }
+        if (ch === "o") {
+          index++;
+          for (; index < max; index++) {
+            ch = data[index];
+            if (ch === "_") continue;
+            if (!isOctCode(data.charCodeAt(index))) return false;
+            hasDigits = true;
+          }
+          return hasDigits && ch !== "_";
+        }
+      }
+      if (ch === "_") return false;
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === "_") continue;
+        if (!isDecCode(data.charCodeAt(index))) {
+          return false;
+        }
+        hasDigits = true;
+      }
+      if (!hasDigits || ch === "_") return false;
+      return true;
+    }
+    function constructYamlInteger(data) {
+      var value = data, sign = 1, ch;
+      if (value.indexOf("_") !== -1) {
+        value = value.replace(/_/g, "");
+      }
+      ch = value[0];
+      if (ch === "-" || ch === "+") {
+        if (ch === "-") sign = -1;
+        value = value.slice(1);
+        ch = value[0];
+      }
+      if (value === "0") return 0;
+      if (ch === "0") {
+        if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+        if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
+        if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
+      }
+      return sign * parseInt(value, 10);
+    }
+    function isInteger(object2) {
+      return Object.prototype.toString.call(object2) === "[object Number]" && (object2 % 1 === 0 && !common.isNegativeZero(object2));
+    }
+    module2.exports = new Type("tag:yaml.org,2002:int", {
+      kind: "scalar",
+      resolve: resolveYamlInteger,
+      construct: constructYamlInteger,
+      predicate: isInteger,
+      represent: {
+        binary: function(obj) {
+          return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+        },
+        octal: function(obj) {
+          return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+        },
+        decimal: function(obj) {
+          return obj.toString(10);
+        },
+        /* eslint-disable max-len */
+        hexadecimal: function(obj) {
+          return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+        }
+      },
+      defaultStyle: "decimal",
+      styleAliases: {
+        binary: [2, "bin"],
+        octal: [8, "oct"],
+        decimal: [10, "dec"],
+        hexadecimal: [16, "hex"]
+      }
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/float.js
+var require_float = __commonJS({
+  "node_modules/js-yaml/lib/type/float.js"(exports2, module2) {
+    "use strict";
+    var common = require_common();
+    var Type = require_type();
+    var YAML_FLOAT_PATTERN = new RegExp(
+      // 2.5e4, 2.5 and integers
+      "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$"
+    );
+    function resolveYamlFloat(data) {
+      if (data === null) return false;
+      if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_`
+      // Probably should update regexp & check speed
+      data[data.length - 1] === "_") {
+        return false;
+      }
+      return true;
+    }
+    function constructYamlFloat(data) {
+      var value, sign;
+      value = data.replace(/_/g, "").toLowerCase();
+      sign = value[0] === "-" ? -1 : 1;
+      if ("+-".indexOf(value[0]) >= 0) {
+        value = value.slice(1);
+      }
+      if (value === ".inf") {
+        return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+      } else if (value === ".nan") {
+        return NaN;
+      }
+      return sign * parseFloat(value, 10);
+    }
+    var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+    function representYamlFloat(object2, style) {
+      var res;
+      if (isNaN(object2)) {
+        switch (style) {
+          case "lowercase":
+            return ".nan";
+          case "uppercase":
+            return ".NAN";
+          case "camelcase":
+            return ".NaN";
+        }
+      } else if (Number.POSITIVE_INFINITY === object2) {
+        switch (style) {
+          case "lowercase":
+            return ".inf";
+          case "uppercase":
+            return ".INF";
+          case "camelcase":
+            return ".Inf";
+        }
+      } else if (Number.NEGATIVE_INFINITY === object2) {
+        switch (style) {
+          case "lowercase":
+            return "-.inf";
+          case "uppercase":
+            return "-.INF";
+          case "camelcase":
+            return "-.Inf";
+        }
+      } else if (common.isNegativeZero(object2)) {
+        return "-0.0";
+      }
+      res = object2.toString(10);
+      return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
+    }
+    function isFloat(object2) {
+      return Object.prototype.toString.call(object2) === "[object Number]" && (object2 % 1 !== 0 || common.isNegativeZero(object2));
+    }
+    module2.exports = new Type("tag:yaml.org,2002:float", {
+      kind: "scalar",
+      resolve: resolveYamlFloat,
+      construct: constructYamlFloat,
+      predicate: isFloat,
+      represent: representYamlFloat,
+      defaultStyle: "lowercase"
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/schema/json.js
+var require_json = __commonJS({
+  "node_modules/js-yaml/lib/schema/json.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_failsafe().extend({
+      implicit: [
+        require_null(),
+        require_bool(),
+        require_int(),
+        require_float()
+      ]
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/schema/core.js
+var require_core = __commonJS({
+  "node_modules/js-yaml/lib/schema/core.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_json();
+  }
+});
+
+// node_modules/js-yaml/lib/type/timestamp.js
+var require_timestamp = __commonJS({
+  "node_modules/js-yaml/lib/type/timestamp.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var YAML_DATE_REGEXP = new RegExp(
+      "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"
+    );
+    var YAML_TIMESTAMP_REGEXP = new RegExp(
+      "^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$"
+    );
+    function resolveYamlTimestamp(data) {
+      if (data === null) return false;
+      if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+      if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+      return false;
+    }
+    function constructYamlTimestamp(data) {
+      var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date5;
+      match = YAML_DATE_REGEXP.exec(data);
+      if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+      if (match === null) throw new Error("Date resolve error");
+      year = +match[1];
+      month = +match[2] - 1;
+      day = +match[3];
+      if (!match[4]) {
+        return new Date(Date.UTC(year, month, day));
+      }
+      hour = +match[4];
+      minute = +match[5];
+      second = +match[6];
+      if (match[7]) {
+        fraction = match[7].slice(0, 3);
+        while (fraction.length < 3) {
+          fraction += "0";
+        }
+        fraction = +fraction;
+      }
+      if (match[9]) {
+        tz_hour = +match[10];
+        tz_minute = +(match[11] || 0);
+        delta = (tz_hour * 60 + tz_minute) * 6e4;
+        if (match[9] === "-") delta = -delta;
+      }
+      date5 = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+      if (delta) date5.setTime(date5.getTime() - delta);
+      return date5;
+    }
+    function representYamlTimestamp(object2) {
+      return object2.toISOString();
+    }
+    module2.exports = new Type("tag:yaml.org,2002:timestamp", {
+      kind: "scalar",
+      resolve: resolveYamlTimestamp,
+      construct: constructYamlTimestamp,
+      instanceOf: Date,
+      represent: representYamlTimestamp
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/merge.js
+var require_merge = __commonJS({
+  "node_modules/js-yaml/lib/type/merge.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    function resolveYamlMerge(data) {
+      return data === "<<" || data === null;
+    }
+    module2.exports = new Type("tag:yaml.org,2002:merge", {
+      kind: "scalar",
+      resolve: resolveYamlMerge
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/binary.js
+var require_binary = __commonJS({
+  "node_modules/js-yaml/lib/type/binary.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+    function resolveYamlBinary(data) {
+      if (data === null) return false;
+      var code, idx, bitlen = 0, max = data.length, map2 = BASE64_MAP;
+      for (idx = 0; idx < max; idx++) {
+        code = map2.indexOf(data.charAt(idx));
+        if (code > 64) continue;
+        if (code < 0) return false;
+        bitlen += 6;
+      }
+      return bitlen % 8 === 0;
+    }
+    function constructYamlBinary(data) {
+      var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map2 = BASE64_MAP, bits = 0, result = [];
+      for (idx = 0; idx < max; idx++) {
+        if (idx % 4 === 0 && idx) {
+          result.push(bits >> 16 & 255);
+          result.push(bits >> 8 & 255);
+          result.push(bits & 255);
+        }
+        bits = bits << 6 | map2.indexOf(input.charAt(idx));
+      }
+      tailbits = max % 4 * 6;
+      if (tailbits === 0) {
+        result.push(bits >> 16 & 255);
+        result.push(bits >> 8 & 255);
+        result.push(bits & 255);
+      } else if (tailbits === 18) {
+        result.push(bits >> 10 & 255);
+        result.push(bits >> 2 & 255);
+      } else if (tailbits === 12) {
+        result.push(bits >> 4 & 255);
+      }
+      return new Uint8Array(result);
+    }
+    function representYamlBinary(object2) {
+      var result = "", bits = 0, idx, tail, max = object2.length, map2 = BASE64_MAP;
+      for (idx = 0; idx < max; idx++) {
+        if (idx % 3 === 0 && idx) {
+          result += map2[bits >> 18 & 63];
+          result += map2[bits >> 12 & 63];
+          result += map2[bits >> 6 & 63];
+          result += map2[bits & 63];
+        }
+        bits = (bits << 8) + object2[idx];
+      }
+      tail = max % 3;
+      if (tail === 0) {
+        result += map2[bits >> 18 & 63];
+        result += map2[bits >> 12 & 63];
+        result += map2[bits >> 6 & 63];
+        result += map2[bits & 63];
+      } else if (tail === 2) {
+        result += map2[bits >> 10 & 63];
+        result += map2[bits >> 4 & 63];
+        result += map2[bits << 2 & 63];
+        result += map2[64];
+      } else if (tail === 1) {
+        result += map2[bits >> 2 & 63];
+        result += map2[bits << 4 & 63];
+        result += map2[64];
+        result += map2[64];
+      }
+      return result;
+    }
+    function isBinary(obj) {
+      return Object.prototype.toString.call(obj) === "[object Uint8Array]";
+    }
+    module2.exports = new Type("tag:yaml.org,2002:binary", {
+      kind: "scalar",
+      resolve: resolveYamlBinary,
+      construct: constructYamlBinary,
+      predicate: isBinary,
+      represent: representYamlBinary
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/omap.js
+var require_omap = __commonJS({
+  "node_modules/js-yaml/lib/type/omap.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var _hasOwnProperty = Object.prototype.hasOwnProperty;
+    var _toString = Object.prototype.toString;
+    function resolveYamlOmap(data) {
+      if (data === null) return true;
+      var objectKeys = [], index, length, pair, pairKey, pairHasKey, object2 = data;
+      for (index = 0, length = object2.length; index < length; index += 1) {
+        pair = object2[index];
+        pairHasKey = false;
+        if (_toString.call(pair) !== "[object Object]") return false;
+        for (pairKey in pair) {
+          if (_hasOwnProperty.call(pair, pairKey)) {
+            if (!pairHasKey) pairHasKey = true;
+            else return false;
+          }
+        }
+        if (!pairHasKey) return false;
+        if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
+        else return false;
+      }
+      return true;
+    }
+    function constructYamlOmap(data) {
+      return data !== null ? data : [];
+    }
+    module2.exports = new Type("tag:yaml.org,2002:omap", {
+      kind: "sequence",
+      resolve: resolveYamlOmap,
+      construct: constructYamlOmap
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/pairs.js
+var require_pairs = __commonJS({
+  "node_modules/js-yaml/lib/type/pairs.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var _toString = Object.prototype.toString;
+    function resolveYamlPairs(data) {
+      if (data === null) return true;
+      var index, length, pair, keys, result, object2 = data;
+      result = new Array(object2.length);
+      for (index = 0, length = object2.length; index < length; index += 1) {
+        pair = object2[index];
+        if (_toString.call(pair) !== "[object Object]") return false;
+        keys = Object.keys(pair);
+        if (keys.length !== 1) return false;
+        result[index] = [keys[0], pair[keys[0]]];
+      }
+      return true;
+    }
+    function constructYamlPairs(data) {
+      if (data === null) return [];
+      var index, length, pair, keys, result, object2 = data;
+      result = new Array(object2.length);
+      for (index = 0, length = object2.length; index < length; index += 1) {
+        pair = object2[index];
+        keys = Object.keys(pair);
+        result[index] = [keys[0], pair[keys[0]]];
+      }
+      return result;
+    }
+    module2.exports = new Type("tag:yaml.org,2002:pairs", {
+      kind: "sequence",
+      resolve: resolveYamlPairs,
+      construct: constructYamlPairs
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/type/set.js
+var require_set = __commonJS({
+  "node_modules/js-yaml/lib/type/set.js"(exports2, module2) {
+    "use strict";
+    var Type = require_type();
+    var _hasOwnProperty = Object.prototype.hasOwnProperty;
+    function resolveYamlSet(data) {
+      if (data === null) return true;
+      var key, object2 = data;
+      for (key in object2) {
+        if (_hasOwnProperty.call(object2, key)) {
+          if (object2[key] !== null) return false;
+        }
+      }
+      return true;
+    }
+    function constructYamlSet(data) {
+      return data !== null ? data : {};
+    }
+    module2.exports = new Type("tag:yaml.org,2002:set", {
+      kind: "mapping",
+      resolve: resolveYamlSet,
+      construct: constructYamlSet
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/schema/default.js
+var require_default = __commonJS({
+  "node_modules/js-yaml/lib/schema/default.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_core().extend({
+      implicit: [
+        require_timestamp(),
+        require_merge()
+      ],
+      explicit: [
+        require_binary(),
+        require_omap(),
+        require_pairs(),
+        require_set()
+      ]
+    });
+  }
+});
+
+// node_modules/js-yaml/lib/loader.js
+var require_loader = __commonJS({
+  "node_modules/js-yaml/lib/loader.js"(exports2, module2) {
+    "use strict";
+    var common = require_common();
+    var YAMLException = require_exception();
+    var makeSnippet = require_snippet();
+    var DEFAULT_SCHEMA = require_default();
+    var _hasOwnProperty = Object.prototype.hasOwnProperty;
+    var CONTEXT_FLOW_IN = 1;
+    var CONTEXT_FLOW_OUT = 2;
+    var CONTEXT_BLOCK_IN = 3;
+    var CONTEXT_BLOCK_OUT = 4;
+    var CHOMPING_CLIP = 1;
+    var CHOMPING_STRIP = 2;
+    var CHOMPING_KEEP = 3;
+    var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+    var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+    var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+    var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+    var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+    function _class(obj) {
+      return Object.prototype.toString.call(obj);
+    }
+    function is_EOL(c) {
+      return c === 10 || c === 13;
+    }
+    function is_WHITE_SPACE(c) {
+      return c === 9 || c === 32;
+    }
+    function is_WS_OR_EOL(c) {
+      return c === 9 || c === 32 || c === 10 || c === 13;
+    }
+    function is_FLOW_INDICATOR(c) {
+      return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+    }
+    function fromHexCode(c) {
+      var lc;
+      if (48 <= c && c <= 57) {
+        return c - 48;
+      }
+      lc = c | 32;
+      if (97 <= lc && lc <= 102) {
+        return lc - 97 + 10;
+      }
+      return -1;
+    }
+    function escapedHexLen(c) {
+      if (c === 120) {
+        return 2;
+      }
+      if (c === 117) {
+        return 4;
+      }
+      if (c === 85) {
+        return 8;
+      }
+      return 0;
+    }
+    function fromDecimalCode(c) {
+      if (48 <= c && c <= 57) {
+        return c - 48;
+      }
+      return -1;
+    }
+    function simpleEscapeSequence(c) {
+      return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "	" : c === 9 ? "	" : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
+    }
+    function charFromCodepoint(c) {
+      if (c <= 65535) {
+        return String.fromCharCode(c);
+      }
+      return String.fromCharCode(
+        (c - 65536 >> 10) + 55296,
+        (c - 65536 & 1023) + 56320
+      );
+    }
+    function setProperty(object2, key, value) {
+      if (key === "__proto__") {
+        Object.defineProperty(object2, key, {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value
+        });
+      } else {
+        object2[key] = value;
+      }
+    }
+    var simpleEscapeCheck = new Array(256);
+    var simpleEscapeMap = new Array(256);
+    for (i = 0; i < 256; i++) {
+      simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+      simpleEscapeMap[i] = simpleEscapeSequence(i);
+    }
+    var i;
+    function State(input, options) {
+      this.input = input;
+      this.filename = options["filename"] || null;
+      this.schema = options["schema"] || DEFAULT_SCHEMA;
+      this.onWarning = options["onWarning"] || null;
+      this.legacy = options["legacy"] || false;
+      this.json = options["json"] || false;
+      this.listener = options["listener"] || null;
+      this.implicitTypes = this.schema.compiledImplicit;
+      this.typeMap = this.schema.compiledTypeMap;
+      this.length = input.length;
+      this.position = 0;
+      this.line = 0;
+      this.lineStart = 0;
+      this.lineIndent = 0;
+      this.firstTabInLine = -1;
+      this.documents = [];
+    }
+    function generateError(state, message) {
+      var mark = {
+        name: state.filename,
+        buffer: state.input.slice(0, -1),
+        // omit trailing \0
+        position: state.position,
+        line: state.line,
+        column: state.position - state.lineStart
+      };
+      mark.snippet = makeSnippet(mark);
+      return new YAMLException(message, mark);
+    }
+    function throwError(state, message) {
+      throw generateError(state, message);
+    }
+    function throwWarning(state, message) {
+      if (state.onWarning) {
+        state.onWarning.call(null, generateError(state, message));
+      }
+    }
+    var directiveHandlers = {
+      YAML: function handleYamlDirective(state, name, args) {
+        var match, major, minor;
+        if (state.version !== null) {
+          throwError(state, "duplication of %YAML directive");
+        }
+        if (args.length !== 1) {
+          throwError(state, "YAML directive accepts exactly one argument");
+        }
+        match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+        if (match === null) {
+          throwError(state, "ill-formed argument of the YAML directive");
+        }
+        major = parseInt(match[1], 10);
+        minor = parseInt(match[2], 10);
+        if (major !== 1) {
+          throwError(state, "unacceptable YAML version of the document");
+        }
+        state.version = args[0];
+        state.checkLineBreaks = minor < 2;
+        if (minor !== 1 && minor !== 2) {
+          throwWarning(state, "unsupported YAML version of the document");
+        }
+      },
+      TAG: function handleTagDirective(state, name, args) {
+        var handle, prefix;
+        if (args.length !== 2) {
+          throwError(state, "TAG directive accepts exactly two arguments");
+        }
+        handle = args[0];
+        prefix = args[1];
+        if (!PATTERN_TAG_HANDLE.test(handle)) {
+          throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+        }
+        if (_hasOwnProperty.call(state.tagMap, handle)) {
+          throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+        }
+        if (!PATTERN_TAG_URI.test(prefix)) {
+          throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+        }
+        try {
+          prefix = decodeURIComponent(prefix);
+        } catch (err) {
+          throwError(state, "tag prefix is malformed: " + prefix);
+        }
+        state.tagMap[handle] = prefix;
+      }
+    };
+    function captureSegment(state, start, end, checkJson) {
+      var _position, _length2, _character, _result;
+      if (start < end) {
+        _result = state.input.slice(start, end);
+        if (checkJson) {
+          for (_position = 0, _length2 = _result.length; _position < _length2; _position += 1) {
+            _character = _result.charCodeAt(_position);
+            if (!(_character === 9 || 32 <= _character && _character <= 1114111)) {
+              throwError(state, "expected valid JSON character");
+            }
+          }
+        } else if (PATTERN_NON_PRINTABLE.test(_result)) {
+          throwError(state, "the stream contains non-printable characters");
+        }
+        state.result += _result;
+      }
+    }
+    function mergeMappings(state, destination, source, overridableKeys) {
+      var sourceKeys, key, index, quantity;
+      if (!common.isObject(source)) {
+        throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+      }
+      sourceKeys = Object.keys(source);
+      for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+        key = sourceKeys[index];
+        if (!_hasOwnProperty.call(destination, key)) {
+          setProperty(destination, key, source[key]);
+          overridableKeys[key] = true;
+        }
+      }
+    }
+    function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+      var index, quantity;
+      if (Array.isArray(keyNode)) {
+        keyNode = Array.prototype.slice.call(keyNode);
+        for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+          if (Array.isArray(keyNode[index])) {
+            throwError(state, "nested arrays are not supported inside keys");
+          }
+          if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") {
+            keyNode[index] = "[object Object]";
+          }
+        }
+      }
+      if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
+        keyNode = "[object Object]";
+      }
+      keyNode = String(keyNode);
+      if (_result === null) {
+        _result = {};
+      }
+      if (keyTag === "tag:yaml.org,2002:merge") {
+        if (Array.isArray(valueNode)) {
+          for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+            mergeMappings(state, _result, valueNode[index], overridableKeys);
+          }
+        } else {
+          mergeMappings(state, _result, valueNode, overridableKeys);
+        }
+      } else {
+        if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
+          state.line = startLine || state.line;
+          state.lineStart = startLineStart || state.lineStart;
+          state.position = startPos || state.position;
+          throwError(state, "duplicated mapping key");
+        }
+        setProperty(_result, keyNode, valueNode);
+        delete overridableKeys[keyNode];
+      }
+      return _result;
+    }
+    function readLineBreak(state) {
+      var ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch === 10) {
+        state.position++;
+      } else if (ch === 13) {
+        state.position++;
+        if (state.input.charCodeAt(state.position) === 10) {
+          state.position++;
+        }
+      } else {
+        throwError(state, "a line break is expected");
+      }
+      state.line += 1;
+      state.lineStart = state.position;
+      state.firstTabInLine = -1;
+    }
+    function skipSeparationSpace(state, allowComments, checkIndent) {
+      var lineBreaks = 0, ch = state.input.charCodeAt(state.position);
+      while (ch !== 0) {
+        while (is_WHITE_SPACE(ch)) {
+          if (ch === 9 && state.firstTabInLine === -1) {
+            state.firstTabInLine = state.position;
+          }
+          ch = state.input.charCodeAt(++state.position);
+        }
+        if (allowComments && ch === 35) {
+          do {
+            ch = state.input.charCodeAt(++state.position);
+          } while (ch !== 10 && ch !== 13 && ch !== 0);
+        }
+        if (is_EOL(ch)) {
+          readLineBreak(state);
+          ch = state.input.charCodeAt(state.position);
+          lineBreaks++;
+          state.lineIndent = 0;
+          while (ch === 32) {
+            state.lineIndent++;
+            ch = state.input.charCodeAt(++state.position);
+          }
+        } else {
+          break;
+        }
+      }
+      if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
+        throwWarning(state, "deficient indentation");
+      }
+      return lineBreaks;
+    }
+    function testDocumentSeparator(state) {
+      var _position = state.position, ch;
+      ch = state.input.charCodeAt(_position);
+      if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+        _position += 3;
+        ch = state.input.charCodeAt(_position);
+        if (ch === 0 || is_WS_OR_EOL(ch)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function writeFoldedLines(state, count) {
+      if (count === 1) {
+        state.result += " ";
+      } else if (count > 1) {
+        state.result += common.repeat("\n", count - 1);
+      }
+    }
+    function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+      var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state.kind, _result = state.result, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
+        return false;
+      }
+      if (ch === 63 || ch === 45) {
+        following = state.input.charCodeAt(state.position + 1);
+        if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
+          return false;
+        }
+      }
+      state.kind = "scalar";
+      state.result = "";
+      captureStart = captureEnd = state.position;
+      hasPendingContent = false;
+      while (ch !== 0) {
+        if (ch === 58) {
+          following = state.input.charCodeAt(state.position + 1);
+          if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
+            break;
+          }
+        } else if (ch === 35) {
+          preceding = state.input.charCodeAt(state.position - 1);
+          if (is_WS_OR_EOL(preceding)) {
+            break;
+          }
+        } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && is_FLOW_INDICATOR(ch)) {
+          break;
+        } else if (is_EOL(ch)) {
+          _line = state.line;
+          _lineStart = state.lineStart;
+          _lineIndent = state.lineIndent;
+          skipSeparationSpace(state, false, -1);
+          if (state.lineIndent >= nodeIndent) {
+            hasPendingContent = true;
+            ch = state.input.charCodeAt(state.position);
+            continue;
+          } else {
+            state.position = captureEnd;
+            state.line = _line;
+            state.lineStart = _lineStart;
+            state.lineIndent = _lineIndent;
+            break;
+          }
+        }
+        if (hasPendingContent) {
+          captureSegment(state, captureStart, captureEnd, false);
+          writeFoldedLines(state, state.line - _line);
+          captureStart = captureEnd = state.position;
+          hasPendingContent = false;
+        }
+        if (!is_WHITE_SPACE(ch)) {
+          captureEnd = state.position + 1;
+        }
+        ch = state.input.charCodeAt(++state.position);
+      }
+      captureSegment(state, captureStart, captureEnd, false);
+      if (state.result) {
+        return true;
+      }
+      state.kind = _kind;
+      state.result = _result;
+      return false;
+    }
+    function readSingleQuotedScalar(state, nodeIndent) {
+      var ch, captureStart, captureEnd;
+      ch = state.input.charCodeAt(state.position);
+      if (ch !== 39) {
+        return false;
+      }
+      state.kind = "scalar";
+      state.result = "";
+      state.position++;
+      captureStart = captureEnd = state.position;
+      while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+        if (ch === 39) {
+          captureSegment(state, captureStart, state.position, true);
+          ch = state.input.charCodeAt(++state.position);
+          if (ch === 39) {
+            captureStart = state.position;
+            state.position++;
+            captureEnd = state.position;
+          } else {
+            return true;
+          }
+        } else if (is_EOL(ch)) {
+          captureSegment(state, captureStart, captureEnd, true);
+          writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+          captureStart = captureEnd = state.position;
+        } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+          throwError(state, "unexpected end of the document within a single quoted scalar");
+        } else {
+          state.position++;
+          captureEnd = state.position;
+        }
+      }
+      throwError(state, "unexpected end of the stream within a single quoted scalar");
+    }
+    function readDoubleQuotedScalar(state, nodeIndent) {
+      var captureStart, captureEnd, hexLength, hexResult, tmp, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch !== 34) {
+        return false;
+      }
+      state.kind = "scalar";
+      state.result = "";
+      state.position++;
+      captureStart = captureEnd = state.position;
+      while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+        if (ch === 34) {
+          captureSegment(state, captureStart, state.position, true);
+          state.position++;
+          return true;
+        } else if (ch === 92) {
+          captureSegment(state, captureStart, state.position, true);
+          ch = state.input.charCodeAt(++state.position);
+          if (is_EOL(ch)) {
+            skipSeparationSpace(state, false, nodeIndent);
+          } else if (ch < 256 && simpleEscapeCheck[ch]) {
+            state.result += simpleEscapeMap[ch];
+            state.position++;
+          } else if ((tmp = escapedHexLen(ch)) > 0) {
+            hexLength = tmp;
+            hexResult = 0;
+            for (; hexLength > 0; hexLength--) {
+              ch = state.input.charCodeAt(++state.position);
+              if ((tmp = fromHexCode(ch)) >= 0) {
+                hexResult = (hexResult << 4) + tmp;
+              } else {
+                throwError(state, "expected hexadecimal character");
+              }
+            }
+            state.result += charFromCodepoint(hexResult);
+            state.position++;
+          } else {
+            throwError(state, "unknown escape sequence");
+          }
+          captureStart = captureEnd = state.position;
+        } else if (is_EOL(ch)) {
+          captureSegment(state, captureStart, captureEnd, true);
+          writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+          captureStart = captureEnd = state.position;
+        } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+          throwError(state, "unexpected end of the document within a double quoted scalar");
+        } else {
+          state.position++;
+          captureEnd = state.position;
+        }
+      }
+      throwError(state, "unexpected end of the stream within a double quoted scalar");
+    }
+    function readFlowCollection(state, nodeIndent) {
+      var readNext = true, _line, _lineStart, _pos, _tag = state.tag, _result, _anchor = state.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch === 91) {
+        terminator = 93;
+        isMapping = false;
+        _result = [];
+      } else if (ch === 123) {
+        terminator = 125;
+        isMapping = true;
+        _result = {};
+      } else {
+        return false;
+      }
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = _result;
+      }
+      ch = state.input.charCodeAt(++state.position);
+      while (ch !== 0) {
+        skipSeparationSpace(state, true, nodeIndent);
+        ch = state.input.charCodeAt(state.position);
+        if (ch === terminator) {
+          state.position++;
+          state.tag = _tag;
+          state.anchor = _anchor;
+          state.kind = isMapping ? "mapping" : "sequence";
+          state.result = _result;
+          return true;
+        } else if (!readNext) {
+          throwError(state, "missed comma between flow collection entries");
+        } else if (ch === 44) {
+          throwError(state, "expected the node content, but found ','");
+        }
+        keyTag = keyNode = valueNode = null;
+        isPair = isExplicitPair = false;
+        if (ch === 63) {
+          following = state.input.charCodeAt(state.position + 1);
+          if (is_WS_OR_EOL(following)) {
+            isPair = isExplicitPair = true;
+            state.position++;
+            skipSeparationSpace(state, true, nodeIndent);
+          }
+        }
+        _line = state.line;
+        _lineStart = state.lineStart;
+        _pos = state.position;
+        composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+        keyTag = state.tag;
+        keyNode = state.result;
+        skipSeparationSpace(state, true, nodeIndent);
+        ch = state.input.charCodeAt(state.position);
+        if ((isExplicitPair || state.line === _line) && ch === 58) {
+          isPair = true;
+          ch = state.input.charCodeAt(++state.position);
+          skipSeparationSpace(state, true, nodeIndent);
+          composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+          valueNode = state.result;
+        }
+        if (isMapping) {
+          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
+        } else if (isPair) {
+          _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
+        } else {
+          _result.push(keyNode);
+        }
+        skipSeparationSpace(state, true, nodeIndent);
+        ch = state.input.charCodeAt(state.position);
+        if (ch === 44) {
+          readNext = true;
+          ch = state.input.charCodeAt(++state.position);
+        } else {
+          readNext = false;
+        }
+      }
+      throwError(state, "unexpected end of the stream within a flow collection");
+    }
+    function readBlockScalar(state, nodeIndent) {
+      var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch === 124) {
+        folding = false;
+      } else if (ch === 62) {
+        folding = true;
+      } else {
+        return false;
+      }
+      state.kind = "scalar";
+      state.result = "";
+      while (ch !== 0) {
+        ch = state.input.charCodeAt(++state.position);
+        if (ch === 43 || ch === 45) {
+          if (CHOMPING_CLIP === chomping) {
+            chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP;
+          } else {
+            throwError(state, "repeat of a chomping mode identifier");
+          }
+        } else if ((tmp = fromDecimalCode(ch)) >= 0) {
+          if (tmp === 0) {
+            throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+          } else if (!detectedIndent) {
+            textIndent = nodeIndent + tmp - 1;
+            detectedIndent = true;
+          } else {
+            throwError(state, "repeat of an indentation width identifier");
+          }
+        } else {
+          break;
+        }
+      }
+      if (is_WHITE_SPACE(ch)) {
+        do {
+          ch = state.input.charCodeAt(++state.position);
+        } while (is_WHITE_SPACE(ch));
+        if (ch === 35) {
+          do {
+            ch = state.input.charCodeAt(++state.position);
+          } while (!is_EOL(ch) && ch !== 0);
+        }
+      }
+      while (ch !== 0) {
+        readLineBreak(state);
+        state.lineIndent = 0;
+        ch = state.input.charCodeAt(state.position);
+        while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
+          state.lineIndent++;
+          ch = state.input.charCodeAt(++state.position);
+        }
+        if (!detectedIndent && state.lineIndent > textIndent) {
+          textIndent = state.lineIndent;
+        }
+        if (is_EOL(ch)) {
+          emptyLines++;
+          continue;
+        }
+        if (state.lineIndent < textIndent) {
+          if (chomping === CHOMPING_KEEP) {
+            state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+          } else if (chomping === CHOMPING_CLIP) {
+            if (didReadContent) {
+              state.result += "\n";
+            }
+          }
+          break;
+        }
+        if (folding) {
+          if (is_WHITE_SPACE(ch)) {
+            atMoreIndented = true;
+            state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+          } else if (atMoreIndented) {
+            atMoreIndented = false;
+            state.result += common.repeat("\n", emptyLines + 1);
+          } else if (emptyLines === 0) {
+            if (didReadContent) {
+              state.result += " ";
+            }
+          } else {
+            state.result += common.repeat("\n", emptyLines);
+          }
+        } else {
+          state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+        }
+        didReadContent = true;
+        detectedIndent = true;
+        emptyLines = 0;
+        captureStart = state.position;
+        while (!is_EOL(ch) && ch !== 0) {
+          ch = state.input.charCodeAt(++state.position);
+        }
+        captureSegment(state, captureStart, state.position, false);
+      }
+      return true;
+    }
+    function readBlockSequence(state, nodeIndent) {
+      var _line, _tag = state.tag, _anchor = state.anchor, _result = [], following, detected = false, ch;
+      if (state.firstTabInLine !== -1) return false;
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = _result;
+      }
+      ch = state.input.charCodeAt(state.position);
+      while (ch !== 0) {
+        if (state.firstTabInLine !== -1) {
+          state.position = state.firstTabInLine;
+          throwError(state, "tab characters must not be used in indentation");
+        }
+        if (ch !== 45) {
+          break;
+        }
+        following = state.input.charCodeAt(state.position + 1);
+        if (!is_WS_OR_EOL(following)) {
+          break;
+        }
+        detected = true;
+        state.position++;
+        if (skipSeparationSpace(state, true, -1)) {
+          if (state.lineIndent <= nodeIndent) {
+            _result.push(null);
+            ch = state.input.charCodeAt(state.position);
+            continue;
+          }
+        }
+        _line = state.line;
+        composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+        _result.push(state.result);
+        skipSeparationSpace(state, true, -1);
+        ch = state.input.charCodeAt(state.position);
+        if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
+          throwError(state, "bad indentation of a sequence entry");
+        } else if (state.lineIndent < nodeIndent) {
+          break;
+        }
+      }
+      if (detected) {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        state.kind = "sequence";
+        state.result = _result;
+        return true;
+      }
+      return false;
+    }
+    function readBlockMapping(state, nodeIndent, flowIndent) {
+      var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state.tag, _anchor = state.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
+      if (state.firstTabInLine !== -1) return false;
+      if (state.anchor !== null) {
+        state.anchorMap[state.anchor] = _result;
+      }
+      ch = state.input.charCodeAt(state.position);
+      while (ch !== 0) {
+        if (!atExplicitKey && state.firstTabInLine !== -1) {
+          state.position = state.firstTabInLine;
+          throwError(state, "tab characters must not be used in indentation");
+        }
+        following = state.input.charCodeAt(state.position + 1);
+        _line = state.line;
+        if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
+          if (ch === 63) {
+            if (atExplicitKey) {
+              storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+              keyTag = keyNode = valueNode = null;
+            }
+            detected = true;
+            atExplicitKey = true;
+            allowCompact = true;
+          } else if (atExplicitKey) {
+            atExplicitKey = false;
+            allowCompact = true;
+          } else {
+            throwError(state, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line");
+          }
+          state.position += 1;
+          ch = following;
+        } else {
+          _keyLine = state.line;
+          _keyLineStart = state.lineStart;
+          _keyPos = state.position;
+          if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+            break;
+          }
+          if (state.line === _line) {
+            ch = state.input.charCodeAt(state.position);
+            while (is_WHITE_SPACE(ch)) {
+              ch = state.input.charCodeAt(++state.position);
+            }
+            if (ch === 58) {
+              ch = state.input.charCodeAt(++state.position);
+              if (!is_WS_OR_EOL(ch)) {
+                throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+              }
+              if (atExplicitKey) {
+                storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+                keyTag = keyNode = valueNode = null;
+              }
+              detected = true;
+              atExplicitKey = false;
+              allowCompact = false;
+              keyTag = state.tag;
+              keyNode = state.result;
+            } else if (detected) {
+              throwError(state, "can not read an implicit mapping pair; a colon is missed");
+            } else {
+              state.tag = _tag;
+              state.anchor = _anchor;
+              return true;
+            }
+          } else if (detected) {
+            throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+          } else {
+            state.tag = _tag;
+            state.anchor = _anchor;
+            return true;
+          }
+        }
+        if (state.line === _line || state.lineIndent > nodeIndent) {
+          if (atExplicitKey) {
+            _keyLine = state.line;
+            _keyLineStart = state.lineStart;
+            _keyPos = state.position;
+          }
+          if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+            if (atExplicitKey) {
+              keyNode = state.result;
+            } else {
+              valueNode = state.result;
+            }
+          }
+          if (!atExplicitKey) {
+            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
+            keyTag = keyNode = valueNode = null;
+          }
+          skipSeparationSpace(state, true, -1);
+          ch = state.input.charCodeAt(state.position);
+        }
+        if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
+          throwError(state, "bad indentation of a mapping entry");
+        } else if (state.lineIndent < nodeIndent) {
+          break;
+        }
+      }
+      if (atExplicitKey) {
+        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+      }
+      if (detected) {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        state.kind = "mapping";
+        state.result = _result;
+      }
+      return detected;
+    }
+    function readTagProperty(state) {
+      var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch !== 33) return false;
+      if (state.tag !== null) {
+        throwError(state, "duplication of a tag property");
+      }
+      ch = state.input.charCodeAt(++state.position);
+      if (ch === 60) {
+        isVerbatim = true;
+        ch = state.input.charCodeAt(++state.position);
+      } else if (ch === 33) {
+        isNamed = true;
+        tagHandle = "!!";
+        ch = state.input.charCodeAt(++state.position);
+      } else {
+        tagHandle = "!";
+      }
+      _position = state.position;
+      if (isVerbatim) {
+        do {
+          ch = state.input.charCodeAt(++state.position);
+        } while (ch !== 0 && ch !== 62);
+        if (state.position < state.length) {
+          tagName = state.input.slice(_position, state.position);
+          ch = state.input.charCodeAt(++state.position);
+        } else {
+          throwError(state, "unexpected end of the stream within a verbatim tag");
+        }
+      } else {
+        while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+          if (ch === 33) {
+            if (!isNamed) {
+              tagHandle = state.input.slice(_position - 1, state.position + 1);
+              if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+                throwError(state, "named tag handle cannot contain such characters");
+              }
+              isNamed = true;
+              _position = state.position + 1;
+            } else {
+              throwError(state, "tag suffix cannot contain exclamation marks");
+            }
+          }
+          ch = state.input.charCodeAt(++state.position);
+        }
+        tagName = state.input.slice(_position, state.position);
+        if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+          throwError(state, "tag suffix cannot contain flow indicator characters");
+        }
+      }
+      if (tagName && !PATTERN_TAG_URI.test(tagName)) {
+        throwError(state, "tag name cannot contain such characters: " + tagName);
+      }
+      try {
+        tagName = decodeURIComponent(tagName);
+      } catch (err) {
+        throwError(state, "tag name is malformed: " + tagName);
+      }
+      if (isVerbatim) {
+        state.tag = tagName;
+      } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
+        state.tag = state.tagMap[tagHandle] + tagName;
+      } else if (tagHandle === "!") {
+        state.tag = "!" + tagName;
+      } else if (tagHandle === "!!") {
+        state.tag = "tag:yaml.org,2002:" + tagName;
+      } else {
+        throwError(state, 'undeclared tag handle "' + tagHandle + '"');
+      }
+      return true;
+    }
+    function readAnchorProperty(state) {
+      var _position, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch !== 38) return false;
+      if (state.anchor !== null) {
+        throwError(state, "duplication of an anchor property");
+      }
+      ch = state.input.charCodeAt(++state.position);
+      _position = state.position;
+      while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+      if (state.position === _position) {
+        throwError(state, "name of an anchor node must contain at least one character");
+      }
+      state.anchor = state.input.slice(_position, state.position);
+      return true;
+    }
+    function readAlias(state) {
+      var _position, alias, ch;
+      ch = state.input.charCodeAt(state.position);
+      if (ch !== 42) return false;
+      ch = state.input.charCodeAt(++state.position);
+      _position = state.position;
+      while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+      if (state.position === _position) {
+        throwError(state, "name of an alias node must contain at least one character");
+      }
+      alias = state.input.slice(_position, state.position);
+      if (!_hasOwnProperty.call(state.anchorMap, alias)) {
+        throwError(state, 'unidentified alias "' + alias + '"');
+      }
+      state.result = state.anchorMap[alias];
+      skipSeparationSpace(state, true, -1);
+      return true;
+    }
+    function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+      var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type, flowIndent, blockIndent;
+      if (state.listener !== null) {
+        state.listener("open", state);
+      }
+      state.tag = null;
+      state.anchor = null;
+      state.kind = null;
+      state.result = null;
+      allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+      if (allowToSeek) {
+        if (skipSeparationSpace(state, true, -1)) {
+          atNewLine = true;
+          if (state.lineIndent > parentIndent) {
+            indentStatus = 1;
+          } else if (state.lineIndent === parentIndent) {
+            indentStatus = 0;
+          } else if (state.lineIndent < parentIndent) {
+            indentStatus = -1;
+          }
+        }
+      }
+      if (indentStatus === 1) {
+        while (readTagProperty(state) || readAnchorProperty(state)) {
+          if (skipSeparationSpace(state, true, -1)) {
+            atNewLine = true;
+            allowBlockCollections = allowBlockStyles;
+            if (state.lineIndent > parentIndent) {
+              indentStatus = 1;
+            } else if (state.lineIndent === parentIndent) {
+              indentStatus = 0;
+            } else if (state.lineIndent < parentIndent) {
+              indentStatus = -1;
+            }
+          } else {
+            allowBlockCollections = false;
+          }
+        }
+      }
+      if (allowBlockCollections) {
+        allowBlockCollections = atNewLine || allowCompact;
+      }
+      if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+        if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
+          flowIndent = parentIndent;
+        } else {
+          flowIndent = parentIndent + 1;
+        }
+        blockIndent = state.position - state.lineStart;
+        if (indentStatus === 1) {
+          if (allowBlockCollections && (readBlockSequence(state, blockIndent) || readBlockMapping(state, blockIndent, flowIndent)) || readFlowCollection(state, flowIndent)) {
+            hasContent = true;
+          } else {
+            if (allowBlockScalars && readBlockScalar(state, flowIndent) || readSingleQuotedScalar(state, flowIndent) || readDoubleQuotedScalar(state, flowIndent)) {
+              hasContent = true;
+            } else if (readAlias(state)) {
+              hasContent = true;
+              if (state.tag !== null || state.anchor !== null) {
+                throwError(state, "alias node should not have any properties");
+              }
+            } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+              hasContent = true;
+              if (state.tag === null) {
+                state.tag = "?";
+              }
+            }
+            if (state.anchor !== null) {
+              state.anchorMap[state.anchor] = state.result;
+            }
+          }
+        } else if (indentStatus === 0) {
+          hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+        }
+      }
+      if (state.tag === null) {
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+      } else if (state.tag === "?") {
+        if (state.result !== null && state.kind !== "scalar") {
+          throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+        }
+        for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+          type = state.implicitTypes[typeIndex];
+          if (type.resolve(state.result)) {
+            state.result = type.construct(state.result);
+            state.tag = type.tag;
+            if (state.anchor !== null) {
+              state.anchorMap[state.anchor] = state.result;
+            }
+            break;
+          }
+        }
+      } else if (state.tag !== "!") {
+        if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) {
+          type = state.typeMap[state.kind || "fallback"][state.tag];
+        } else {
+          type = null;
+          typeList = state.typeMap.multi[state.kind || "fallback"];
+          for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
+            if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
+              type = typeList[typeIndex];
+              break;
+            }
+          }
+        }
+        if (!type) {
+          throwError(state, "unknown tag !<" + state.tag + ">");
+        }
+        if (state.result !== null && type.kind !== state.kind) {
+          throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
+        }
+        if (!type.resolve(state.result, state.tag)) {
+          throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+        } else {
+          state.result = type.construct(state.result, state.tag);
+          if (state.anchor !== null) {
+            state.anchorMap[state.anchor] = state.result;
+          }
+        }
+      }
+      if (state.listener !== null) {
+        state.listener("close", state);
+      }
+      return state.tag !== null || state.anchor !== null || hasContent;
+    }
+    function readDocument(state) {
+      var documentStart = state.position, _position, directiveName, directiveArgs, hasDirectives = false, ch;
+      state.version = null;
+      state.checkLineBreaks = state.legacy;
+      state.tagMap = /* @__PURE__ */ Object.create(null);
+      state.anchorMap = /* @__PURE__ */ Object.create(null);
+      while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+        skipSeparationSpace(state, true, -1);
+        ch = state.input.charCodeAt(state.position);
+        if (state.lineIndent > 0 || ch !== 37) {
+          break;
+        }
+        hasDirectives = true;
+        ch = state.input.charCodeAt(++state.position);
+        _position = state.position;
+        while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+          ch = state.input.charCodeAt(++state.position);
+        }
+        directiveName = state.input.slice(_position, state.position);
+        directiveArgs = [];
+        if (directiveName.length < 1) {
+          throwError(state, "directive name must not be less than one character in length");
+        }
+        while (ch !== 0) {
+          while (is_WHITE_SPACE(ch)) {
+            ch = state.input.charCodeAt(++state.position);
+          }
+          if (ch === 35) {
+            do {
+              ch = state.input.charCodeAt(++state.position);
+            } while (ch !== 0 && !is_EOL(ch));
+            break;
+          }
+          if (is_EOL(ch)) break;
+          _position = state.position;
+          while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+            ch = state.input.charCodeAt(++state.position);
+          }
+          directiveArgs.push(state.input.slice(_position, state.position));
+        }
+        if (ch !== 0) readLineBreak(state);
+        if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
+          directiveHandlers[directiveName](state, directiveName, directiveArgs);
+        } else {
+          throwWarning(state, 'unknown document directive "' + directiveName + '"');
+        }
+      }
+      skipSeparationSpace(state, true, -1);
+      if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
+        state.position += 3;
+        skipSeparationSpace(state, true, -1);
+      } else if (hasDirectives) {
+        throwError(state, "directives end mark is expected");
+      }
+      composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+      skipSeparationSpace(state, true, -1);
+      if (state.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
+        throwWarning(state, "non-ASCII line breaks are interpreted as content");
+      }
+      state.documents.push(state.result);
+      if (state.position === state.lineStart && testDocumentSeparator(state)) {
+        if (state.input.charCodeAt(state.position) === 46) {
+          state.position += 3;
+          skipSeparationSpace(state, true, -1);
+        }
+        return;
+      }
+      if (state.position < state.length - 1) {
+        throwError(state, "end of the stream or a document separator is expected");
+      } else {
+        return;
+      }
+    }
+    function loadDocuments(input, options) {
+      input = String(input);
+      options = options || {};
+      if (input.length !== 0) {
+        if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
+          input += "\n";
+        }
+        if (input.charCodeAt(0) === 65279) {
+          input = input.slice(1);
+        }
+      }
+      var state = new State(input, options);
+      var nullpos = input.indexOf("\0");
+      if (nullpos !== -1) {
+        state.position = nullpos;
+        throwError(state, "null byte is not allowed in input");
+      }
+      state.input += "\0";
+      while (state.input.charCodeAt(state.position) === 32) {
+        state.lineIndent += 1;
+        state.position += 1;
+      }
+      while (state.position < state.length - 1) {
+        readDocument(state);
+      }
+      return state.documents;
+    }
+    function loadAll(input, iterator, options) {
+      if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") {
+        options = iterator;
+        iterator = null;
+      }
+      var documents = loadDocuments(input, options);
+      if (typeof iterator !== "function") {
+        return documents;
+      }
+      for (var index = 0, length = documents.length; index < length; index += 1) {
+        iterator(documents[index]);
+      }
+    }
+    function load2(input, options) {
+      var documents = loadDocuments(input, options);
+      if (documents.length === 0) {
+        return void 0;
+      } else if (documents.length === 1) {
+        return documents[0];
+      }
+      throw new YAMLException("expected a single document in the stream, but found more");
+    }
+    module2.exports.loadAll = loadAll;
+    module2.exports.load = load2;
+  }
+});
+
+// node_modules/js-yaml/lib/dumper.js
+var require_dumper = __commonJS({
+  "node_modules/js-yaml/lib/dumper.js"(exports2, module2) {
+    "use strict";
+    var common = require_common();
+    var YAMLException = require_exception();
+    var DEFAULT_SCHEMA = require_default();
+    var _toString = Object.prototype.toString;
+    var _hasOwnProperty = Object.prototype.hasOwnProperty;
+    var CHAR_BOM = 65279;
+    var CHAR_TAB = 9;
+    var CHAR_LINE_FEED = 10;
+    var CHAR_CARRIAGE_RETURN = 13;
+    var CHAR_SPACE = 32;
+    var CHAR_EXCLAMATION = 33;
+    var CHAR_DOUBLE_QUOTE = 34;
+    var CHAR_SHARP = 35;
+    var CHAR_PERCENT = 37;
+    var CHAR_AMPERSAND = 38;
+    var CHAR_SINGLE_QUOTE = 39;
+    var CHAR_ASTERISK = 42;
+    var CHAR_COMMA = 44;
+    var CHAR_MINUS = 45;
+    var CHAR_COLON = 58;
+    var CHAR_EQUALS = 61;
+    var CHAR_GREATER_THAN = 62;
+    var CHAR_QUESTION = 63;
+    var CHAR_COMMERCIAL_AT = 64;
+    var CHAR_LEFT_SQUARE_BRACKET = 91;
+    var CHAR_RIGHT_SQUARE_BRACKET = 93;
+    var CHAR_GRAVE_ACCENT = 96;
+    var CHAR_LEFT_CURLY_BRACKET = 123;
+    var CHAR_VERTICAL_LINE = 124;
+    var CHAR_RIGHT_CURLY_BRACKET = 125;
+    var ESCAPE_SEQUENCES = {};
+    ESCAPE_SEQUENCES[0] = "\\0";
+    ESCAPE_SEQUENCES[7] = "\\a";
+    ESCAPE_SEQUENCES[8] = "\\b";
+    ESCAPE_SEQUENCES[9] = "\\t";
+    ESCAPE_SEQUENCES[10] = "\\n";
+    ESCAPE_SEQUENCES[11] = "\\v";
+    ESCAPE_SEQUENCES[12] = "\\f";
+    ESCAPE_SEQUENCES[13] = "\\r";
+    ESCAPE_SEQUENCES[27] = "\\e";
+    ESCAPE_SEQUENCES[34] = '\\"';
+    ESCAPE_SEQUENCES[92] = "\\\\";
+    ESCAPE_SEQUENCES[133] = "\\N";
+    ESCAPE_SEQUENCES[160] = "\\_";
+    ESCAPE_SEQUENCES[8232] = "\\L";
+    ESCAPE_SEQUENCES[8233] = "\\P";
+    var DEPRECATED_BOOLEANS_SYNTAX = [
+      "y",
+      "Y",
+      "yes",
+      "Yes",
+      "YES",
+      "on",
+      "On",
+      "ON",
+      "n",
+      "N",
+      "no",
+      "No",
+      "NO",
+      "off",
+      "Off",
+      "OFF"
+    ];
+    var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
+    function compileStyleMap(schema, map2) {
+      var result, keys, index, length, tag, style, type;
+      if (map2 === null) return {};
+      result = {};
+      keys = Object.keys(map2);
+      for (index = 0, length = keys.length; index < length; index += 1) {
+        tag = keys[index];
+        style = String(map2[tag]);
+        if (tag.slice(0, 2) === "!!") {
+          tag = "tag:yaml.org,2002:" + tag.slice(2);
+        }
+        type = schema.compiledTypeMap["fallback"][tag];
+        if (type && _hasOwnProperty.call(type.styleAliases, style)) {
+          style = type.styleAliases[style];
+        }
+        result[tag] = style;
+      }
+      return result;
+    }
+    function encodeHex(character) {
+      var string4, handle, length;
+      string4 = character.toString(16).toUpperCase();
+      if (character <= 255) {
+        handle = "x";
+        length = 2;
+      } else if (character <= 65535) {
+        handle = "u";
+        length = 4;
+      } else if (character <= 4294967295) {
+        handle = "U";
+        length = 8;
+      } else {
+        throw new YAMLException("code point within a string may not be greater than 0xFFFFFFFF");
+      }
+      return "\\" + handle + common.repeat("0", length - string4.length) + string4;
+    }
+    var QUOTING_TYPE_SINGLE = 1;
+    var QUOTING_TYPE_DOUBLE = 2;
+    function State(options) {
+      this.schema = options["schema"] || DEFAULT_SCHEMA;
+      this.indent = Math.max(1, options["indent"] || 2);
+      this.noArrayIndent = options["noArrayIndent"] || false;
+      this.skipInvalid = options["skipInvalid"] || false;
+      this.flowLevel = common.isNothing(options["flowLevel"]) ? -1 : options["flowLevel"];
+      this.styleMap = compileStyleMap(this.schema, options["styles"] || null);
+      this.sortKeys = options["sortKeys"] || false;
+      this.lineWidth = options["lineWidth"] || 80;
+      this.noRefs = options["noRefs"] || false;
+      this.noCompatMode = options["noCompatMode"] || false;
+      this.condenseFlow = options["condenseFlow"] || false;
+      this.quotingType = options["quotingType"] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
+      this.forceQuotes = options["forceQuotes"] || false;
+      this.replacer = typeof options["replacer"] === "function" ? options["replacer"] : null;
+      this.implicitTypes = this.schema.compiledImplicit;
+      this.explicitTypes = this.schema.compiledExplicit;
+      this.tag = null;
+      this.result = "";
+      this.duplicates = [];
+      this.usedDuplicates = null;
+    }
+    function indentString(string4, spaces) {
+      var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string4.length;
+      while (position < length) {
+        next = string4.indexOf("\n", position);
+        if (next === -1) {
+          line = string4.slice(position);
+          position = length;
+        } else {
+          line = string4.slice(position, next + 1);
+          position = next + 1;
+        }
+        if (line.length && line !== "\n") result += ind;
+        result += line;
+      }
+      return result;
+    }
+    function generateNextLine(state, level) {
+      return "\n" + common.repeat(" ", state.indent * level);
+    }
+    function testImplicitResolving(state, str) {
+      var index, length, type;
+      for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
+        type = state.implicitTypes[index];
+        if (type.resolve(str)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function isWhitespace(c) {
+      return c === CHAR_SPACE || c === CHAR_TAB;
+    }
+    function isPrintable(c) {
+      return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== CHAR_BOM || 65536 <= c && c <= 1114111;
+    }
+    function isNsCharOrWhitespace(c) {
+      return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+    }
+    function isPlainSafe(c, prev, inblock) {
+      var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+      var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+      return (
+        // ns-plain-safe
+        (inblock ? (
+          // c = flow-in
+          cIsNsCharOrWhitespace
+        ) : cIsNsCharOrWhitespace && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET) && c !== CHAR_SHARP && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar
+      );
+    }
+    function isPlainSafeFirst(c) {
+      return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_EQUALS && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
+    }
+    function isPlainSafeLast(c) {
+      return !isWhitespace(c) && c !== CHAR_COLON;
+    }
+    function codePointAt(string4, pos) {
+      var first = string4.charCodeAt(pos), second;
+      if (first >= 55296 && first <= 56319 && pos + 1 < string4.length) {
+        second = string4.charCodeAt(pos + 1);
+        if (second >= 56320 && second <= 57343) {
+          return (first - 55296) * 1024 + second - 56320 + 65536;
+        }
+      }
+      return first;
+    }
+    function needIndentIndicator(string4) {
+      var leadingSpaceRe = /^\n* /;
+      return leadingSpaceRe.test(string4);
+    }
+    var STYLE_PLAIN = 1;
+    var STYLE_SINGLE = 2;
+    var STYLE_LITERAL = 3;
+    var STYLE_FOLDED = 4;
+    var STYLE_DOUBLE = 5;
+    function chooseScalarStyle(string4, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
+      var i;
+      var char = 0;
+      var prevChar = null;
+      var hasLineBreak = false;
+      var hasFoldableLine = false;
+      var shouldTrackWidth = lineWidth !== -1;
+      var previousLineBreak = -1;
+      var plain = isPlainSafeFirst(codePointAt(string4, 0)) && isPlainSafeLast(codePointAt(string4, string4.length - 1));
+      if (singleLineOnly || forceQuotes) {
+        for (i = 0; i < string4.length; char >= 65536 ? i += 2 : i++) {
+          char = codePointAt(string4, i);
+          if (!isPrintable(char)) {
+            return STYLE_DOUBLE;
+          }
+          plain = plain && isPlainSafe(char, prevChar, inblock);
+          prevChar = char;
+        }
+      } else {
+        for (i = 0; i < string4.length; char >= 65536 ? i += 2 : i++) {
+          char = codePointAt(string4, i);
+          if (char === CHAR_LINE_FEED) {
+            hasLineBreak = true;
+            if (shouldTrackWidth) {
+              hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented.
+              i - previousLineBreak - 1 > lineWidth && string4[previousLineBreak + 1] !== " ";
+              previousLineBreak = i;
+            }
+          } else if (!isPrintable(char)) {
+            return STYLE_DOUBLE;
+          }
+          plain = plain && isPlainSafe(char, prevChar, inblock);
+          prevChar = char;
+        }
+        hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string4[previousLineBreak + 1] !== " ");
+      }
+      if (!hasLineBreak && !hasFoldableLine) {
+        if (plain && !forceQuotes && !testAmbiguousType(string4)) {
+          return STYLE_PLAIN;
+        }
+        return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+      }
+      if (indentPerLevel > 9 && needIndentIndicator(string4)) {
+        return STYLE_DOUBLE;
+      }
+      if (!forceQuotes) {
+        return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+      }
+      return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+    }
+    function writeScalar(state, string4, level, iskey, inblock) {
+      state.dump = (function() {
+        if (string4.length === 0) {
+          return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
+        }
+        if (!state.noCompatMode) {
+          if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string4) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string4)) {
+            return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string4 + '"' : "'" + string4 + "'";
+          }
+        }
+        var indent = state.indent * Math.max(1, level);
+        var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+        var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+        function testAmbiguity(string5) {
+          return testImplicitResolving(state, string5);
+        }
+        switch (chooseScalarStyle(
+          string4,
+          singleLineOnly,
+          state.indent,
+          lineWidth,
+          testAmbiguity,
+          state.quotingType,
+          state.forceQuotes && !iskey,
+          inblock
+        )) {
+          case STYLE_PLAIN:
+            return string4;
+          case STYLE_SINGLE:
+            return "'" + string4.replace(/'/g, "''") + "'";
+          case STYLE_LITERAL:
+            return "|" + blockHeader(string4, state.indent) + dropEndingNewline(indentString(string4, indent));
+          case STYLE_FOLDED:
+            return ">" + blockHeader(string4, state.indent) + dropEndingNewline(indentString(foldString(string4, lineWidth), indent));
+          case STYLE_DOUBLE:
+            return '"' + escapeString(string4, lineWidth) + '"';
+          default:
+            throw new YAMLException("impossible error: invalid scalar style");
+        }
+      })();
+    }
+    function blockHeader(string4, indentPerLevel) {
+      var indentIndicator = needIndentIndicator(string4) ? String(indentPerLevel) : "";
+      var clip = string4[string4.length - 1] === "\n";
+      var keep = clip && (string4[string4.length - 2] === "\n" || string4 === "\n");
+      var chomp = keep ? "+" : clip ? "" : "-";
+      return indentIndicator + chomp + "\n";
+    }
+    function dropEndingNewline(string4) {
+      return string4[string4.length - 1] === "\n" ? string4.slice(0, -1) : string4;
+    }
+    function foldString(string4, width) {
+      var lineRe = /(\n+)([^\n]*)/g;
+      var result = (function() {
+        var nextLF = string4.indexOf("\n");
+        nextLF = nextLF !== -1 ? nextLF : string4.length;
+        lineRe.lastIndex = nextLF;
+        return foldLine(string4.slice(0, nextLF), width);
+      })();
+      var prevMoreIndented = string4[0] === "\n" || string4[0] === " ";
+      var moreIndented;
+      var match;
+      while (match = lineRe.exec(string4)) {
+        var prefix = match[1], line = match[2];
+        moreIndented = line[0] === " ";
+        result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
+        prevMoreIndented = moreIndented;
+      }
+      return result;
+    }
+    function foldLine(line, width) {
+      if (line === "" || line[0] === " ") return line;
+      var breakRe = / [^ ]/g;
+      var match;
+      var start = 0, end, curr = 0, next = 0;
+      var result = "";
+      while (match = breakRe.exec(line)) {
+        next = match.index;
+        if (next - start > width) {
+          end = curr > start ? curr : next;
+          result += "\n" + line.slice(start, end);
+          start = end + 1;
+        }
+        curr = next;
+      }
+      result += "\n";
+      if (line.length - start > width && curr > start) {
+        result += line.slice(start, curr) + "\n" + line.slice(curr + 1);
+      } else {
+        result += line.slice(start);
+      }
+      return result.slice(1);
+    }
+    function escapeString(string4) {
+      var result = "";
+      var char = 0;
+      var escapeSeq;
+      for (var i = 0; i < string4.length; char >= 65536 ? i += 2 : i++) {
+        char = codePointAt(string4, i);
+        escapeSeq = ESCAPE_SEQUENCES[char];
+        if (!escapeSeq && isPrintable(char)) {
+          result += string4[i];
+          if (char >= 65536) result += string4[i + 1];
+        } else {
+          result += escapeSeq || encodeHex(char);
+        }
+      }
+      return result;
+    }
+    function writeFlowSequence(state, level, object2) {
+      var _result = "", _tag = state.tag, index, length, value;
+      for (index = 0, length = object2.length; index < length; index += 1) {
+        value = object2[index];
+        if (state.replacer) {
+          value = state.replacer.call(object2, String(index), value);
+        }
+        if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
+          if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
+          _result += state.dump;
+        }
+      }
+      state.tag = _tag;
+      state.dump = "[" + _result + "]";
+    }
+    function writeBlockSequence(state, level, object2, compact) {
+      var _result = "", _tag = state.tag, index, length, value;
+      for (index = 0, length = object2.length; index < length; index += 1) {
+        value = object2[index];
+        if (state.replacer) {
+          value = state.replacer.call(object2, String(index), value);
+        }
+        if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
+          if (!compact || _result !== "") {
+            _result += generateNextLine(state, level);
+          }
+          if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+            _result += "-";
+          } else {
+            _result += "- ";
+          }
+          _result += state.dump;
+        }
+      }
+      state.tag = _tag;
+      state.dump = _result || "[]";
+    }
+    function writeFlowMapping(state, level, object2) {
+      var _result = "", _tag = state.tag, objectKeyList = Object.keys(object2), index, length, objectKey, objectValue, pairBuffer;
+      for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+        pairBuffer = "";
+        if (_result !== "") pairBuffer += ", ";
+        if (state.condenseFlow) pairBuffer += '"';
+        objectKey = objectKeyList[index];
+        objectValue = object2[objectKey];
+        if (state.replacer) {
+          objectValue = state.replacer.call(object2, objectKey, objectValue);
+        }
+        if (!writeNode(state, level, objectKey, false, false)) {
+          continue;
+        }
+        if (state.dump.length > 1024) pairBuffer += "? ";
+        pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
+        if (!writeNode(state, level, objectValue, false, false)) {
+          continue;
+        }
+        pairBuffer += state.dump;
+        _result += pairBuffer;
+      }
+      state.tag = _tag;
+      state.dump = "{" + _result + "}";
+    }
+    function writeBlockMapping(state, level, object2, compact) {
+      var _result = "", _tag = state.tag, objectKeyList = Object.keys(object2), index, length, objectKey, objectValue, explicitPair, pairBuffer;
+      if (state.sortKeys === true) {
+        objectKeyList.sort();
+      } else if (typeof state.sortKeys === "function") {
+        objectKeyList.sort(state.sortKeys);
+      } else if (state.sortKeys) {
+        throw new YAMLException("sortKeys must be a boolean or a function");
+      }
+      for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+        pairBuffer = "";
+        if (!compact || _result !== "") {
+          pairBuffer += generateNextLine(state, level);
+        }
+        objectKey = objectKeyList[index];
+        objectValue = object2[objectKey];
+        if (state.replacer) {
+          objectValue = state.replacer.call(object2, objectKey, objectValue);
+        }
+        if (!writeNode(state, level + 1, objectKey, true, true, true)) {
+          continue;
+        }
+        explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+        if (explicitPair) {
+          if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+            pairBuffer += "?";
+          } else {
+            pairBuffer += "? ";
+          }
+        }
+        pairBuffer += state.dump;
+        if (explicitPair) {
+          pairBuffer += generateNextLine(state, level);
+        }
+        if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
+          continue;
+        }
+        if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+          pairBuffer += ":";
+        } else {
+          pairBuffer += ": ";
+        }
+        pairBuffer += state.dump;
+        _result += pairBuffer;
+      }
+      state.tag = _tag;
+      state.dump = _result || "{}";
+    }
+    function detectType(state, object2, explicit) {
+      var _result, typeList, index, length, type, style;
+      typeList = explicit ? state.explicitTypes : state.implicitTypes;
+      for (index = 0, length = typeList.length; index < length; index += 1) {
+        type = typeList[index];
+        if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object2 === "object" && object2 instanceof type.instanceOf) && (!type.predicate || type.predicate(object2))) {
+          if (explicit) {
+            if (type.multi && type.representName) {
+              state.tag = type.representName(object2);
+            } else {
+              state.tag = type.tag;
+            }
+          } else {
+            state.tag = "?";
+          }
+          if (type.represent) {
+            style = state.styleMap[type.tag] || type.defaultStyle;
+            if (_toString.call(type.represent) === "[object Function]") {
+              _result = type.represent(object2, style);
+            } else if (_hasOwnProperty.call(type.represent, style)) {
+              _result = type.represent[style](object2, style);
+            } else {
+              throw new YAMLException("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
+            }
+            state.dump = _result;
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+    function writeNode(state, level, object2, block, compact, iskey, isblockseq) {
+      state.tag = null;
+      state.dump = object2;
+      if (!detectType(state, object2, false)) {
+        detectType(state, object2, true);
+      }
+      var type = _toString.call(state.dump);
+      var inblock = block;
+      var tagStr;
+      if (block) {
+        block = state.flowLevel < 0 || state.flowLevel > level;
+      }
+      var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
+      if (objectOrArray) {
+        duplicateIndex = state.duplicates.indexOf(object2);
+        duplicate = duplicateIndex !== -1;
+      }
+      if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
+        compact = false;
+      }
+      if (duplicate && state.usedDuplicates[duplicateIndex]) {
+        state.dump = "*ref_" + duplicateIndex;
+      } else {
+        if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
+          state.usedDuplicates[duplicateIndex] = true;
+        }
+        if (type === "[object Object]") {
+          if (block && Object.keys(state.dump).length !== 0) {
+            writeBlockMapping(state, level, state.dump, compact);
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + state.dump;
+            }
+          } else {
+            writeFlowMapping(state, level, state.dump);
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+            }
+          }
+        } else if (type === "[object Array]") {
+          if (block && state.dump.length !== 0) {
+            if (state.noArrayIndent && !isblockseq && level > 0) {
+              writeBlockSequence(state, level - 1, state.dump, compact);
+            } else {
+              writeBlockSequence(state, level, state.dump, compact);
+            }
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + state.dump;
+            }
+          } else {
+            writeFlowSequence(state, level, state.dump);
+            if (duplicate) {
+              state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+            }
+          }
+        } else if (type === "[object String]") {
+          if (state.tag !== "?") {
+            writeScalar(state, state.dump, level, iskey, inblock);
+          }
+        } else if (type === "[object Undefined]") {
+          return false;
+        } else {
+          if (state.skipInvalid) return false;
+          throw new YAMLException("unacceptable kind of an object to dump " + type);
+        }
+        if (state.tag !== null && state.tag !== "?") {
+          tagStr = encodeURI(
+            state.tag[0] === "!" ? state.tag.slice(1) : state.tag
+          ).replace(/!/g, "%21");
+          if (state.tag[0] === "!") {
+            tagStr = "!" + tagStr;
+          } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") {
+            tagStr = "!!" + tagStr.slice(18);
+          } else {
+            tagStr = "!<" + tagStr + ">";
+          }
+          state.dump = tagStr + " " + state.dump;
+        }
+      }
+      return true;
+    }
+    function getDuplicateReferences(object2, state) {
+      var objects = [], duplicatesIndexes = [], index, length;
+      inspectNode(object2, objects, duplicatesIndexes);
+      for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
+        state.duplicates.push(objects[duplicatesIndexes[index]]);
+      }
+      state.usedDuplicates = new Array(length);
+    }
+    function inspectNode(object2, objects, duplicatesIndexes) {
+      var objectKeyList, index, length;
+      if (object2 !== null && typeof object2 === "object") {
+        index = objects.indexOf(object2);
+        if (index !== -1) {
+          if (duplicatesIndexes.indexOf(index) === -1) {
+            duplicatesIndexes.push(index);
+          }
+        } else {
+          objects.push(object2);
+          if (Array.isArray(object2)) {
+            for (index = 0, length = object2.length; index < length; index += 1) {
+              inspectNode(object2[index], objects, duplicatesIndexes);
+            }
+          } else {
+            objectKeyList = Object.keys(object2);
+            for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+              inspectNode(object2[objectKeyList[index]], objects, duplicatesIndexes);
+            }
+          }
+        }
+      }
+    }
+    function dump(input, options) {
+      options = options || {};
+      var state = new State(options);
+      if (!state.noRefs) getDuplicateReferences(input, state);
+      var value = input;
+      if (state.replacer) {
+        value = state.replacer.call({ "": value }, "", value);
+      }
+      if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+      return "";
+    }
+    module2.exports.dump = dump;
+  }
+});
+
+// node_modules/js-yaml/index.js
+var require_js_yaml = __commonJS({
+  "node_modules/js-yaml/index.js"(exports2, module2) {
+    "use strict";
+    var loader = require_loader();
+    var dumper = require_dumper();
+    function renamed(from, to) {
+      return function() {
+        throw new Error("Function yaml." + from + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default.");
+      };
+    }
+    module2.exports.Type = require_type();
+    module2.exports.Schema = require_schema();
+    module2.exports.FAILSAFE_SCHEMA = require_failsafe();
+    module2.exports.JSON_SCHEMA = require_json();
+    module2.exports.CORE_SCHEMA = require_core();
+    module2.exports.DEFAULT_SCHEMA = require_default();
+    module2.exports.load = loader.load;
+    module2.exports.loadAll = loader.loadAll;
+    module2.exports.dump = dumper.dump;
+    module2.exports.YAMLException = require_exception();
+    module2.exports.types = {
+      binary: require_binary(),
+      float: require_float(),
+      map: require_map(),
+      null: require_null(),
+      pairs: require_pairs(),
+      set: require_set(),
+      timestamp: require_timestamp(),
+      bool: require_bool(),
+      int: require_int(),
+      merge: require_merge(),
+      omap: require_omap(),
+      seq: require_seq(),
+      str: require_str()
+    };
+    module2.exports.safeLoad = renamed("safeLoad", "load");
+    module2.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+    module2.exports.safeDump = renamed("safeDump", "dump");
+  }
+});
+
 // node_modules/chardet/lib/fs/node.js
 var require_node = __commonJS({
   "node_modules/chardet/lib/fs/node.js"(exports2, module2) {
@@ -5607,10 +8403,10 @@ var require_lib = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs14 = (0, node_1.default)();
+      const fs23 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs14.closeSync(fd);
+          fs23.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -5622,9 +8418,9 @@ var require_lib = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs14.openSync(filepath, "r");
+        fd = fs23.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs14.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs23.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -5636,22 +8432,22 @@ var require_lib = __commonJS({
         });
         return;
       }
-      fs14.readFile(filepath, handler);
+      fs23.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs14 = (0, node_1.default)();
+      const fs23 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs14.openSync(filepath, "r");
+        const fd = fs23.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs14.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs23.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs14.closeSync(fd);
+        fs23.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs14.readFileSync(filepath));
+      return (0, exports2.detect)(fs23.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -5788,6 +8584,7 @@ var DEFAULT_CONFIG_JSON5 = `{
   maxBlockFileSize: 50, // \u6700\u5927\u5206\u5757\u6587\u4EF6\u5927\u5C0F\uFF0C\u5355\u4F4DKB\uFF1B\u8D85\u8FC7\u8BE5\u5927\u5C0F\u7684\u6587\u4EF6\u9700\u8981\u5206\u5757\u5904\u7406
   encoding: 'auto', // \u547D\u4EE4\u884C\u7F16\u7801\u683C\u5F0F\uFF0C\u53EF\u8BBE\u7F6E\u4E3A utf-8\u3001gbk \u7B49\uFF0C\u4E5F\u53EF\u4EE5\u8BBE\u7F6E\u6210 auto \u6216\u7A7A\u503C\u81EA\u52A8\u5224\u65AD
   maxSubAgentCount: 2, // "\u6700\u5927\u5B50agent\u5E76\u884C\u6267\u884C\u6570\u91CF", -1 \u8868\u793A\u65E0\u9650\u5236
+  isPrintThinking: true, // \u662F\u5426\u6253\u5370 AI \u601D\u8003\u8FC7\u7A0B\u4E2D\u7684\u4E2D\u95F4\u4FE1\u606F\uFF0C\u9ED8\u8BA4\u4E3A true
   serve: {
       port: 8866,
   }
@@ -5894,7 +8691,7 @@ function getScanDirPaths() {
   const workspacePath = getWorkspacePath();
   const homePath = getHomePath();
   const paths = /* @__PURE__ */ new Set();
-  paths.add(import_path2.default.join(workspacePath, ".deepfish"));
+  paths.add(import_path2.default.join(workspacePath, ".deepfish-ai"));
   paths.add(import_path2.default.join(homePath));
   return Array.from(paths);
 }
@@ -6070,11 +8867,11 @@ function handleModelLs() {
   const currentModel = config2.currentModel;
   logInfo("=".repeat(50));
   aiList.forEach((item, index) => {
-    const isCurrent = item.name === currentModel ? "current" : " ";
+    const isCurrent = item.name === currentModel;
     if (isCurrent) {
-      logSuccess(`[${index}] ${item.name} (${item.model}) [${isCurrent}]`);
+      logSuccess(`[${index}] ${item.name} (${item.model}) [\u221A]`);
     } else {
-      logInfo(`[${index}] ${item.name} (${item.model})`);
+      logInfo(`[${index}] ${item.name} (${item.model}) [\xD7]`);
     }
   });
   logInfo("=".repeat(50));
@@ -6140,9 +8937,9 @@ function registerModelsCommands(program) {
 
 // src/cli/cli-core/skills.ts
 var import_crypto5 = require("crypto");
-var import_inquirer2 = __toESM(require("inquirer"));
-var import_fs_extra12 = __toESM(require("fs-extra"));
-var import_path14 = __toESM(require("path"));
+var import_inquirer3 = __toESM(require("inquirer"));
+var import_fs_extra19 = __toESM(require("fs-extra"));
+var import_path19 = __toESM(require("path"));
 
 // src/cli/cli-utils/init-config.ts
 var import_fs_extra4 = __toESM(require("fs-extra"));
@@ -6199,12 +8996,12 @@ function getConfig() {
 }
 
 // src/cli/cli-utils/init-agent.ts
-var import_fs_extra11 = __toESM(require("fs-extra"));
-var import_path13 = __toESM(require("path"));
+var import_fs_extra18 = __toESM(require("fs-extra"));
+var import_path18 = __toESM(require("path"));
 var import_crypto4 = require("crypto");
 
 // src/agent/AIAgent/index.ts
-var import_langchain6 = require("langchain");
+var import_langchain15 = require("langchain");
 var import_deepagents = require("deepagents");
 
 // src/agent/AIAgent/utils/langgraph-checkpoint-filesystem/filesystem-saver.ts
@@ -6487,10 +9284,17 @@ var BaseCheckpointSaver = class {
     while (cursorConfig != null && remaining.size > 0) {
       const tup = await this.getTuple(cursorConfig);
       if (tup === void 0) break;
-      if (tup.pendingWrites && tup.pendingWrites.length > 0) for (let i = tup.pendingWrites.length - 1; i >= 0; i -= 1) {
-        const write = tup.pendingWrites[i];
-        const ch = write[1];
-        if (remaining.has(ch)) collectedByCh[ch].push(write);
+      if (tup.pendingWrites && tup.pendingWrites.length > 0) {
+        const perChannel = {};
+        for (const write of tup.pendingWrites) {
+          const ch = write[1];
+          if (remaining.has(ch)) (perChannel[ch] ??= []).push(write);
+        }
+        for (const ch of Object.keys(perChannel)) {
+          const block = perChannel[ch];
+          block.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+          for (let i = block.length - 1; i >= 0; i -= 1) collectedByCh[ch].push(block[i]);
+        }
       }
       for (const ch of Array.from(remaining)) if (Object.prototype.hasOwnProperty.call(tup.checkpoint.channel_values, ch)) {
         seedByCh[ch] = tup.checkpoint.channel_values[ch];
@@ -7682,10 +10486,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path21) {
+  if (!path21)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path21.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8094,11 +10898,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path21, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path21);
     return iss;
   });
 }
@@ -8245,16 +11049,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path15 = []) => {
+  const processError = (error52, path21 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path21, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -8281,17 +11085,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path15 = []) => {
+  const processError = (error52, path21 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path15, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path15, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path21, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8323,8 +11127,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path15) {
+  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path21) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21016,13 +23820,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path15 = ref.slice(1).split("/").filter(Boolean);
-  if (path15.length === 0) {
+  const path21 = ref.slice(1).split("/").filter(Boolean);
+  if (path21.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path15[0] === defsKey) {
-    const key = path15[1];
+  if (path21[0] === defsKey) {
+    const key = path21[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -21489,38 +24293,135 @@ function createAgentEventMiddleware(emitter) {
 var Thinking = class {
   isThinking = false;
   loadingEvent = null;
-  content = "";
-  init() {
-    this.content = "";
-    this.isThinking = true;
-    this.loadingEvent = loading("Thinking...");
+  start() {
+    if (!this.isThinking) {
+      this.isThinking = true;
+      this.loadingEvent = loading("Thinking...");
+    }
   }
   stop() {
     this.isThinking = false;
-    this.content = "";
     if (this.loadingEvent) {
       this.loadingEvent("I have finished thinking.");
       this.loadingEvent = null;
     }
   }
-  setStop(content) {
-    if (this.isThinking) {
-      this.content += content.replace(/\s+/g, "");
-      if (this.content.length > 0) {
-        this.stop();
-      }
-    }
-  }
 };
 
+// src/agent/AIAgent/utils/skill-parser.ts
+var fs5 = require("fs-extra");
+var path4 = require("path");
+var yaml = require_js_yaml();
+function extractFrontmatter(content, skillPath) {
+  const normalizedContent = content.replace(/^\uFEFF/, "");
+  const frontmatterMatch = normalizedContent.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/);
+  if (!frontmatterMatch) {
+    throw new Error(`No frontmatter found in ${skillPath}`);
+  }
+  return frontmatterMatch[1];
+}
+function parseSkillMetadataYaml(skillPath) {
+  const content = fs5.readFileSync(skillPath, "utf-8");
+  const frontmatterContent = extractFrontmatter(content, skillPath);
+  const frontmatter = yaml.load(frontmatterContent);
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    homepage: frontmatter.homepage,
+    location: path4.dirname(skillPath),
+    metadata: frontmatter.metadata || {},
+    skillFilePath: skillPath
+  };
+}
+
 // src/agent/AIAgent/system-prompt.ts
-var systemPrompt = (workspace, osType) => `
-\u8FD9\u662FDeepfish Cli\u7CFB\u7EDF\uFF0C\u4F60\u662F\u7CFB\u7EDF\u4E2D\u4E25\u683C\u6309\u89C4\u5219\u6267\u884C\u4EFB\u52A1\u7684\u667A\u80FD\u4F53\uFF0C\u4E0D\u80FD\u8FDD\u53CD\u4EFB\u4F55\u7CFB\u7EDF\u9650\u5236\u3002
+var import_fs_extra5 = __toESM(require("fs-extra"));
+function getSkillPrompt(skills) {
+  const parsedSkills = skills.map((skill) => {
+    return parseSkillMetadataYaml(skill);
+  });
+  let skillPrompt = "";
+  if (parsedSkills.length > 0) {
+    const skillTable = parsedSkills.map((s) => `| ${s.name} | ${s.description} | ${s.location} | ${s.skillFilePath} |`).join("\n");
+    skillPrompt = `
+### \u53EF\u4EE5\u4F7F\u7528\u7684Skills
+\u53EF\u4EE5\u8C03\u7528\u4EE5\u4E0BSkill\u6765\u5B8C\u6210\u7528\u6237\u4EFB\u52A1\u76EE\u6807,Skill\u7684\u8C03\u7528\u65B9\u5F0F:
+- \u4F7F\u7528\u7528\u6237\u8BF7\u6C42\u5339\u914D skill description,
+- \u4E00\u6B21\u53EA\u52A0\u8F7D\u4E00\u4E2ASkill,\u4F18\u5148\u5339\u914D\u6700\u5177\u4F53\u7684Skill
+- \u5F53\u7528\u6237\u8BF7\u6C42\u4E0D\u5339\u914D\u4EFB\u4F55Skill\u63CF\u8FF0\u65F6,\u4E0D\u52A0\u8F7D\u4EFB\u4F55Skill
+- \u5F53\u5339\u914D\u5230Skill\u65F6, \u521B\u5EFA\u4E00\u4E2A\u5B50\u667A\u80FD\u4F53,\u5C06SKILL.md\u7684\u6587\u4EF6\u8DEF\u5F84\u548C\u4EFB\u52A1\u76EE\u6807\u4F20\u9012\u7ED9\u5B50\u667A\u80FD\u4F53,\u5B50\u667A\u80FD\u4F53\u901A\u8FC7\u8BFB\u53D6SKILL.md\u6587\u4EF6\u83B7\u53D6\u8C03\u7528\u8BF4\u660E,\u901A\u8FC7\u4ED4\u7EC6\u9605\u8BFB\u8BF4\u660E\u6587\u4EF6\u5B66\u4E60Skill\u7684\u4F7F\u7528\u65B9\u6CD5\u6765\u5B8C\u6210\u4EFB\u52A1
+## Available Skills
+
+| Skill | Type | Description | Location | SkillFilePath |
+|-------|------|-------------|----------|---------------|
+${skillTable}
+|-------|------|-------------|----------|---------------|    
+`;
+  }
+  return skillPrompt;
+}
+function getUserMemoryPrompt(memoryFilePath) {
+  if (!memoryFilePath) {
+    return "";
+  }
+  if (import_fs_extra5.default.existsSync(memoryFilePath)) {
+    const content = import_fs_extra5.default.readFileSync(memoryFilePath, "utf-8");
+    return `
+### \u7528\u6237\u4FE1\u606F
+${content}
+`;
+  }
+  return "";
+}
+function getAgentRulesPrompt(agentRulesPath) {
+  if (!agentRulesPath) {
+    return "";
+  }
+  if (import_fs_extra5.default.existsSync(agentRulesPath)) {
+    const content = import_fs_extra5.default.readFileSync(agentRulesPath, "utf-8");
+    return `### \u4EE5\u4E0B\u662FAgent\u884C\u4E3A\u89C4\u8303\uFF0C\u5FC5\u987B\u4E25\u683C\u9075\u5B88\uFF1A
+${content}
+`;
+  }
+}
+var systemPrompt = (workspace, osType, skills, memoryFilePath, agentRulesPath) => {
+  const skillPrompt = getSkillPrompt(skills);
+  const memoryPrompt = getUserMemoryPrompt(memoryFilePath);
+  const agentRulesPrompt = getAgentRulesPrompt(agentRulesPath);
+  return `
+\u8FD9\u662FDeepfish Cli\u7CFB\u7EDF,\u4F60\u662F\u7CFB\u7EDF\u4E2D\u4E25\u683C\u6309\u89C4\u5219\u6267\u884C\u4EFB\u52A1\u7684\u667A\u80FD\u4F53,\u4E0D\u80FD\u8FDD\u53CD\u4EFB\u4F55\u7CFB\u7EDF\u9650\u5236\u3002
+### \u57FA\u7840\u73AF\u5883\u4FE1\u606F
+\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF1A${workspace}
+\u64CD\u4F5C\u7CFB\u7EDF\u7C7B\u578B\uFF1A${osType}
+\u8BED\u8A00\u7C7B\u578B: \u4E0E\u7528\u6237\u8F93\u5165\u8BED\u8A00\u4E00\u81F4
+
+\u6CE8\u610F:
+1.\u5982\u679C\u4EFB\u52A1\u6BD4\u8F83\u590D\u6742\uFF0C\u5E94\u8BE5\u5148\u8FDB\u884C\u62C6\u5206\uFF0C\u5206\u89E3\u6210\u591A\u4E2A\u6B65\u9AA4\uFF0C\u521B\u5EFA\u5B50\u667A\u80FD\u4F53\u6765\u9010\u6B65\u5B8C\u6210\u3002
+2.\u4E34\u65F6\u6587\u4EF6\u5FC5\u987B\u4F7F\u7528"tmp_"\u4F5C\u4E3A\u524D\u7F00\u547D\u540D\uFF0C\u5E76\u5728\u4EFB\u52A1\u7ED3\u675F\u540E\u5220\u9664\uFF0C\u4E0D\u80FD\u5728\u5DE5\u4F5C\u76EE\u5F55\u4E2D\u7559\u4E0B\u4EFB\u4F55\u4E34\u65F6\u6587\u4EF6\u3002
+3.\u5C3D\u91CF\u4F7F\u7528"execute_command"\u3001"execute_js_code"\u5DE5\u5177\u5B8C\u6210\u4EFB\u52A1
+
+${skillPrompt}
+${memoryPrompt}
+${agentRulesPrompt}
+`;
+};
+var subSystemPrompt = (workspace, osType, skills) => {
+  let skillPrompt = getSkillPrompt(skills);
+  return `
+\u8FD9\u662FDeepfish Cli\u7CFB\u7EDF,\u4F60\u662F\u7CFB\u7EDF\u4E2D\u4E25\u683C\u6309\u89C4\u5219\u6267\u884C\u4EFB\u52A1\u7684\u5B50\u667A\u80FD\u4F53,\u4E0D\u80FD\u8FDD\u53CD\u4EFB\u4F55\u7CFB\u7EDF\u9650\u5236\u3002
 ### \u57FA\u7840\u73AF\u5883\u4FE1\u606F
 \u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF1A${workspace}
 \u64CD\u4F5C\u7CFB\u7EDF\u7C7B\u578B\uFF1A${osType}
 \u8BED\u8A00\u7C7B\u578B: \u4E0E\u7528\u6237\u8F93\u5165\u8BED\u8A00\u4E00\u81F4
+
+\u6CE8\u610F:
+1.\u5B50\u667A\u80FD\u4F53\u53EA\u80FD\u5B8C\u6210\u5355\u4E2A\u4EFB\u52A1,\u4E0D\u80FD\u521B\u5EFA\u65B0\u7684\u5B50\u667A\u80FD\u4F53\u3002
+2.\u4E34\u65F6\u6587\u4EF6\u5FC5\u987B\u4F7F\u7528"tmp_"\u4F5C\u4E3A\u524D\u7F00\u547D\u540D\uFF0C\u5E76\u5728\u4EFB\u52A1\u7ED3\u675F\u540E\u5220\u9664\uFF0C\u4E0D\u80FD\u5728\u5DE5\u4F5C\u76EE\u5F55\u4E2D\u7559\u4E0B\u4EFB\u4F55\u4E34\u65F6\u6587\u4EF6\u3002
+3.\u5C3D\u91CF\u4F7F\u7528"execute_command"\u3001"execute_js_code"\u5DE5\u5177\u5B8C\u6210\u4EFB\u52A1
+
+${skillPrompt}
 `;
+};
 
 // src/agent/tools/executeCommand.ts
 var import_child_process2 = require("child_process");
@@ -21531,13 +24432,13 @@ var import_langchain2 = require("langchain");
 
 // src/cli/cli-utils/getGlobalData.ts
 var import_path6 = __toESM(require("path"));
-var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_fs_extra6 = __toESM(require("fs-extra"));
 function getServePort() {
   const port = getConfig()?.serve?.port || 8866;
   return port;
 }
 function getVersion() {
-  const packageJson = import_fs_extra5.default.readJSONSync(import_path6.default.join(getCodePath(), "package.json"));
+  const packageJson = import_fs_extra6.default.readJSONSync(import_path6.default.join(getCodePath(), "package.json"));
   return packageJson.version;
 }
 function getEncoding() {
@@ -21607,7 +24508,7 @@ var executeCommandTool = (0, import_langchain2.tool)(
 // src/agent/tools/executeJSCode.ts
 var import_langchain3 = require("langchain");
 var import_path7 = __toESM(require("path"));
-var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
 var _require = require;
 async function executeJSCode(code) {
   logInfo("Executing JavaScript code: ");
@@ -21629,7 +24530,7 @@ async function executeJSCode(code) {
 var getInstalledPackagesTool = (0, import_langchain3.tool)(
   async () => {
     const packageJson = import_path7.default.join(getCodePath(), "./package.json");
-    const pkg = import_fs_extra6.default.readJsonSync(packageJson);
+    const pkg = import_fs_extra7.default.readJsonSync(packageJson);
     return JSON.stringify(pkg.dependencies);
   },
   {
@@ -21641,7 +24542,7 @@ var getInstalledPackagesTool = (0, import_langchain3.tool)(
 var checkPackageInstalledTool = (0, import_langchain3.tool)(
   async ({ packageName }) => {
     const packageJson = import_path7.default.join(getCodePath(), "./package.json");
-    const pkg = import_fs_extra6.default.readJsonSync(packageJson);
+    const pkg = import_fs_extra7.default.readJsonSync(packageJson);
     const installed = Object.prototype.hasOwnProperty.call(pkg.dependencies, packageName);
     return installed ? `Package "${packageName}" is installed.` : `Package "${packageName}" is NOT installed.`;
   },
@@ -21656,7 +24557,7 @@ var checkPackageInstalledTool = (0, import_langchain3.tool)(
 var installPackageTool = (0, import_langchain3.tool)(
   async ({ packageName }) => {
     const packageJson = import_path7.default.join(getCodePath(), "./package.json");
-    const pkg = import_fs_extra6.default.readJsonSync(packageJson);
+    const pkg = import_fs_extra7.default.readJsonSync(packageJson);
     if (Object.prototype.hasOwnProperty.call(pkg.dependencies, packageName)) {
       return `Package "${packageName}" is already installed.`;
     }
@@ -21670,7 +24571,6 @@ var installPackageTool = (0, import_langchain3.tool)(
     })
   }
 );
-var packageTools = [getInstalledPackagesTool, checkPackageInstalledTool, installPackageTool];
 var executeJSCodeTool = (0, import_langchain3.tool)(
   async ({ code }) => {
     const result = await executeJSCode(code);
@@ -21678,21 +24578,22 @@ var executeJSCodeTool = (0, import_langchain3.tool)(
   },
   {
     name: "execute_js_code",
-    description: `\u5728\u5F53\u524D Node.js \u73AF\u5883\u4E2D\u6267\u884C\u4E00\u6BB5 JavaScript \u4EE3\u7801\u5B57\u7B26\u4E32\u5E76\u8FD4\u56DE\u6267\u884C\u7ED3\u679C\u3002\u6CE8\u610F\uFF1A\u4EE3\u7801\u5FC5\u987B\u5305\u542B\u4E00\u4E2A__main()\u51FD\u6570\u4F5C\u4E3A\u6267\u884C\u5165\u53E3\uFF0C__main()\u51FD\u6570\u5185\u5FC5\u987B\u662F\u4E00\u4E2A\u4F7F\u7528async\u524D\u7F00\u7684\u51FD\u6570\u3002\u793A\u4F8B\u4EE3\u7801\uFF1A
+    description: `\u6267\u884C\u4E00\u6BB5Node.js\u4EE3\u7801\u5E76\u8FD4\u56DE\u6267\u884C\u7ED3\u679C\u3002\u6CE8\u610F\uFF1A\u4EE3\u7801\u5FC5\u987B\u5305\u542B\u4E00\u4E2A__main()\u51FD\u6570\u4F5C\u4E3A\u6267\u884C\u5165\u53E3\uFF0C__main()\u51FD\u6570\u5185\u5FC5\u987B\u662F\u4E00\u4E2A\u4F7F\u7528async\u524D\u7F00\u7684\u51FD\u6570\u3002\u793A\u4F8B\u4EE3\u7801\uFF1A
         async function __main() {
           const data = await fs.readFile("data.txt", "utf-8")
           return data
         }
         `,
     schema: external_exports.object({
-      code: external_exports.string().describe("\u8981\u6267\u884C\u7684 JavaScript \u4EE3\u7801")
+      code: external_exports.string().describe("\u8981\u6267\u884C\u7684Node.js\u4EE3\u7801")
     })
   }
 );
+var packageTools = [getInstalledPackagesTool, checkPackageInstalledTool, installPackageTool, executeJSCodeTool];
 
 // src/cli/cli-utils/UserCache.ts
 var import_path8 = __toESM(require("path"));
-var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
 var import_crypto = require("crypto");
 var UserCache = class {
   cacheDir;
@@ -21700,23 +24601,23 @@ var UserCache = class {
   constructor() {
     const cacheDir = getUserStorePath();
     const catalog = import_path8.default.join(cacheDir, "catalog.json");
-    import_fs_extra7.default.ensureFileSync(catalog);
+    import_fs_extra8.default.ensureFileSync(catalog);
     this.cacheDir = cacheDir;
     this.catalogPath = catalog;
   }
   getCatalog() {
-    return import_fs_extra7.default.readJSONSync(this.catalogPath, { throws: false }) || [];
+    return import_fs_extra8.default.readJSONSync(this.catalogPath, { throws: false }) || [];
   }
   getCatalogFilePath() {
     return this.catalogPath;
   }
   updateCatalog(catalog) {
-    import_fs_extra7.default.writeJSONSync(this.catalogPath, catalog);
+    import_fs_extra8.default.writeJSONSync(this.catalogPath, catalog);
   }
   add(description, content) {
     const id = (0, import_crypto.randomUUID)();
     const filePath = import_path8.default.join(this.cacheDir, `${id}.md`);
-    import_fs_extra7.default.writeFileSync(filePath, content, "utf-8");
+    import_fs_extra8.default.writeFileSync(filePath, content, "utf-8");
     const catalog = this.getCatalog();
     catalog.push({ id, description });
     this.updateCatalog(catalog);
@@ -21726,8 +24627,8 @@ var UserCache = class {
     const item = catalog.find((item2) => item2.id === id);
     if (item) {
       const filePath = import_path8.default.join(this.cacheDir, `${id}.md`);
-      if (import_fs_extra7.default.existsSync(filePath)) {
-        return { description: item.description, content: import_fs_extra7.default.readFileSync(filePath, "utf-8") };
+      if (import_fs_extra8.default.existsSync(filePath)) {
+        return { description: item.description, content: import_fs_extra8.default.readFileSync(filePath, "utf-8") };
       }
     }
     return { description: "", content: "" };
@@ -21751,8 +24652,8 @@ var UserCache = class {
     catalog.splice(idx, 1);
     this.updateCatalog(catalog);
     const filePath = import_path8.default.join(this.cacheDir, `${id}.md`);
-    if (import_fs_extra7.default.existsSync(filePath)) {
-      import_fs_extra7.default.removeSync(filePath);
+    if (import_fs_extra8.default.existsSync(filePath)) {
+      import_fs_extra8.default.removeSync(filePath);
     }
     return true;
   }
@@ -21771,7 +24672,7 @@ var UserCache = class {
       return false;
     }
     const filePath = import_path8.default.join(this.cacheDir, `${id}.md`);
-    import_fs_extra7.default.writeFileSync(filePath, content, "utf-8");
+    import_fs_extra8.default.writeFileSync(filePath, content, "utf-8");
     return true;
   }
 };
@@ -21853,44 +24754,49 @@ var learnTools = [learnSelfTool, getLearnedDetailTool, updateLearnContentTool, g
 
 // src/agent/tools/mcp.ts
 var import_mcp_adapters = require("@langchain/mcp-adapters");
-var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_fs_extra9 = __toESM(require("fs-extra"));
 var import_path9 = __toESM(require("path"));
 async function loadMcpToolsFromConfigPath(mcpFilePath) {
-  const jsonContent = import_fs_extra8.default.readJSONSync(mcpFilePath);
+  const jsonContent = import_fs_extra9.default.readJSONSync(mcpFilePath);
   const { mcpServers } = jsonContent;
-  if (!mcpServers || mcpServers.length === 0) {
+  if (!mcpServers || Object.keys(mcpServers).length === 0) {
     return [];
   }
-  for (const key of Object.keys(mcpServers)) {
-    const server = mcpServers[key];
-    if (!server.transport) {
-      if (server.url) {
-        if (server.url.startsWith("ws://") || server.url.startsWith("wss://")) {
-          server.transport = "websocket";
-        } else if (server.url.startsWith("http://") || server.url.startsWith("https://")) {
-          server.transport = "http";
+  try {
+    for (const key of Object.keys(mcpServers)) {
+      const server = mcpServers[key];
+      if (!server.transport) {
+        if (server.url) {
+          if (server.url.startsWith("ws://") || server.url.startsWith("wss://")) {
+            server.transport = "websocket";
+          } else if (server.url.startsWith("http://") || server.url.startsWith("https://")) {
+            server.transport = "http";
+          }
+        } else if (server.command === "node" || server.command === "npx") {
+          server.transport = "stdio";
         }
-      } else if (server.command === "node" || server.command === "npx") {
-        server.transport = "stdio";
+      }
+      if (!server.transport) {
+        logWarning(`Unable to determine transport for MCP server ${key}, skipping...`);
+        delete mcpServers[key];
       }
     }
-    if (!server.transport) {
-      logWarning(`Unable to determine transport for MCP server ${key}, skipping...`);
-      delete mcpServers[key];
-    }
+    logInfo(`Loading MCP tools from config path: ${mcpFilePath}`);
+    const client = new import_mcp_adapters.MultiServerMCPClient(jsonContent.mcpServers);
+    const tools = await client.getTools();
+    logInfo(`Loaded ${tools.length} tools from MCP config.`);
+    return tools;
+  } catch (error51) {
+    console.log("Error loading MCP tools:", error51);
+    return [];
   }
-  logInfo(`Loading MCP tools from config path: ${mcpFilePath}`);
-  const client = new import_mcp_adapters.MultiServerMCPClient(jsonContent.mcpServers);
-  const tools = await client.getTools();
-  logInfo(`Loaded ${tools.length} tools from MCP config.`);
-  return tools;
 }
 async function scanUserMcp() {
   const tools = [];
   const scanPaths = getScanDirPaths();
   for (const scanPath of scanPaths) {
     const mcpFilePath = import_path9.default.join(scanPath, "mcp.json");
-    if (import_fs_extra8.default.existsSync(mcpFilePath)) {
+    if (import_fs_extra9.default.existsSync(mcpFilePath)) {
       const mcpTools = await loadMcpToolsFromConfigPath(mcpFilePath);
       tools.push(...mcpTools);
     }
@@ -21901,7 +24807,7 @@ async function scanUserMcp() {
 // src/agent/tools/utils.ts
 var import_langchain5 = require("langchain");
 var import_path10 = __toESM(require("path"));
-var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_fs_extra10 = __toESM(require("fs-extra"));
 var import_crypto2 = require("crypto");
 function toLangChainTool(func, description) {
   const { name, description: desc, parameters } = description.function;
@@ -21951,12 +24857,12 @@ function scanUserTools() {
   const scanPaths = getScanDirPaths();
   scanPaths.forEach((scanPath) => {
     const toolsDir = import_path10.default.resolve(scanPath, "tools");
-    if (import_fs_extra9.default.pathExistsSync(toolsDir)) {
-      const files = import_fs_extra9.default.readdirSync(toolsDir);
+    if (import_fs_extra10.default.pathExistsSync(toolsDir)) {
+      const files = import_fs_extra10.default.readdirSync(toolsDir);
       files.forEach((file2) => {
-        if (import_fs_extra9.default.statSync(import_path10.default.resolve(toolsDir, file2)).isDirectory()) {
+        if (import_fs_extra10.default.statSync(import_path10.default.resolve(toolsDir, file2)).isDirectory()) {
           const subDirPath = import_path10.default.resolve(toolsDir, file2);
-          const subFiles = import_fs_extra9.default.readdirSync(subDirPath);
+          const subFiles = import_fs_extra10.default.readdirSync(subDirPath);
           const indexFile = subFiles.find((f) => f === "index" || f === "index.cjs");
           if (indexFile) {
             const filePath = _scanDeepFishJsFile(import_path10.default.resolve(subDirPath, indexFile), indexFile);
@@ -21984,7 +24890,7 @@ function scanUserTools() {
 }
 function _scanDeepFishJsFile(filePath, fileName) {
   if (fileName.endsWith(".js") || fileName.endsWith(".cjs")) {
-    const fileContent = import_fs_extra9.default.readFileSync(filePath, "utf-8");
+    const fileContent = import_fs_extra10.default.readFileSync(filePath, "utf-8");
     if (fileContent.includes("module.exports") && fileContent.includes("descriptions") && fileContent.includes("functions")) {
       return filePath;
     }
@@ -22003,21 +24909,381 @@ function _loadToolsFromFile(filePath, tools) {
   });
 }
 
-// src/agent/tools/index.ts
-async function getTools() {
-  return [executeCommandTool, executeJSCodeTool, ...packageTools, ...learnTools, ...await scanUserTools(), ...await scanUserMcp()];
-}
+// src/agent/tools/edit.ts
+var import_fs_extra12 = __toESM(require("fs-extra"));
+var import_langchain6 = require("langchain");
 
-// src/agent/skills/index.ts
+// src/agent/tools/fileTools.ts
+var import_fs_extra11 = __toESM(require("fs-extra"));
 var import_path11 = __toESM(require("path"));
-function getSkills() {
-  return [...getRegisteredSkills(), import_path11.default.join(__dirname, "./view-learn-cache.md")];
+var DEFAULT_MAX_OUTPUT = 6e4;
+var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".json",
+  ".json5",
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".css",
+  ".less",
+  ".scss",
+  ".html",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".env",
+  ".gitignore",
+  ".sql",
+  ".py",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".go",
+  ".rs",
+  ".php",
+  ".rb",
+  ".sh",
+  ".bat",
+  ".ps1",
+  ".vue",
+  ".svelte",
+  ".log",
+  ".csv"
+]);
+function resolveWorkspacePath(inputPath, cwd = getTrueCwd()) {
+  if (!inputPath?.trim()) {
+    throw new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  return import_path11.default.resolve(cwd, inputPath);
+}
+function normalizePathForMatch(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function truncateOutput(content, maxLength = DEFAULT_MAX_OUTPUT) {
+  if (content.length <= maxLength) {
+    return content;
+  }
+  return `${content.slice(0, maxLength)}
+
+[\u5185\u5BB9\u5DF2\u622A\u65AD\uFF0C\u4EC5\u663E\u793A\u524D ${maxLength} \u4E2A\u5B57\u7B26\uFF0C\u603B\u957F\u5EA6 ${content.length} \u4E2A\u5B57\u7B26]`;
+}
+function isProbablyTextFile(filePath) {
+  const ext = import_path11.default.extname(filePath).toLowerCase();
+  const base = import_path11.default.basename(filePath).toLowerCase();
+  return TEXT_FILE_EXTENSIONS.has(ext) || TEXT_FILE_EXTENSIONS.has(base) || base.startsWith(".env");
+}
+function globToRegExp(pattern) {
+  const normalized = normalizePathForMatch(pattern);
+  let regex = "^";
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized[i];
+    const next = normalized[i + 1];
+    if (char === "*") {
+      if (next === "*") {
+        const after = normalized[i + 2];
+        if (after === "/") {
+          regex += "(?:.*/)?";
+          i += 2;
+        } else {
+          regex += ".*";
+          i += 1;
+        }
+      } else {
+        regex += "[^/]*";
+      }
+    } else if (char === "?") {
+      regex += "[^/]";
+    } else {
+      regex += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  regex += "$";
+  return new RegExp(regex, "i");
+}
+function matchesGlob(relativePath, pattern) {
+  return globToRegExp(pattern).test(normalizePathForMatch(relativePath));
+}
+async function walkFiles(rootDir, options = {}) {
+  const files = [];
+  const includeHidden = options.includeHidden ?? false;
+  const maxFiles = options.maxFiles ?? 5e3;
+  async function walk(currentDir) {
+    if (files.length >= maxFiles) {
+      return;
+    }
+    const entries = await import_fs_extra11.default.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (files.length >= maxFiles) {
+        return;
+      }
+      if (!includeHidden && entry.name.startsWith(".")) {
+        continue;
+      }
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === ".git") {
+        continue;
+      }
+      const fullPath = import_path11.default.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+// src/agent/tools/edit.ts
+async function editFileByReplace(filePath, oldString, newString, replaceAll = false) {
+  const absPath = resolveWorkspacePath(filePath);
+  if (!await import_fs_extra12.default.pathExists(absPath)) {
+    return `Edit error: \u6587\u4EF6\u4E0D\u5B58\u5728 ${absPath}`;
+  }
+  const content = await import_fs_extra12.default.readFile(absPath, "utf-8");
+  const matches = content.split(oldString).length - 1;
+  if (!oldString) {
+    return "Edit error: oldString \u4E0D\u80FD\u4E3A\u7A7A";
+  }
+  if (matches === 0) {
+    return "Edit error: \u672A\u627E\u5230 oldString\uFF0C\u8BF7\u5148\u8BFB\u53D6\u6587\u4EF6\u786E\u8BA4\u7CBE\u786E\u5185\u5BB9";
+  }
+  if (!replaceAll && matches > 1) {
+    return `Edit error: oldString \u5339\u914D\u5230 ${matches} \u5904\u3002\u8BF7\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u4F7F\u5176\u552F\u4E00\uFF0C\u6216\u8BBE\u7F6E replaceAll=true`;
+  }
+  const nextContent = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+  await import_fs_extra12.default.writeFile(absPath, nextContent, "utf-8");
+  return `\u5DF2\u7F16\u8F91\u6587\u4EF6: ${absPath}\uFF0C\u66FF\u6362 ${replaceAll ? matches : 1} \u5904`;
+}
+var editFileTool = (0, import_langchain6.tool)(
+  async ({ filePath, oldString, newString, replaceAll }) => editFileByReplace(filePath, oldString, newString, replaceAll),
+  {
+    name: "edit_file",
+    description: "\u7F16\u8F91\u5DF2\u6709\u6587\u672C\u6587\u4EF6\uFF1A\u4F7F\u7528\u7CBE\u786E oldString \u66FF\u6362\u4E3A newString\u3002\u9ED8\u8BA4\u8981\u6C42 oldString \u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u4EE5\u907F\u514D\u8BEF\u6539\u3002",
+    schema: external_exports.object({
+      filePath: external_exports.string().describe("\u8981\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84\uFF0C\u652F\u6301\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u8DEF\u5F84"),
+      oldString: external_exports.string().describe("\u8981\u66FF\u6362\u7684\u539F\u59CB\u6587\u672C\uFF0C\u5FC5\u987B\u4E0E\u6587\u4EF6\u5185\u5BB9\u5B8C\u5168\u4E00\u81F4\uFF1B\u5EFA\u8BAE\u5305\u542B\u8DB3\u591F\u4E0A\u4E0B\u6587\u4FDD\u8BC1\u552F\u4E00"),
+      newString: external_exports.string().describe("\u66FF\u6362\u540E\u7684\u65B0\u6587\u672C"),
+      replaceAll: external_exports.boolean().default(false).describe("\u662F\u5426\u66FF\u6362\u5168\u90E8\u5339\u914D\u9879\uFF1B\u9ED8\u8BA4 false\uFF0C\u4EC5\u5141\u8BB8\u552F\u4E00\u5339\u914D")
+    })
+  }
+);
+
+// src/agent/tools/glob.ts
+var import_path12 = __toESM(require("path"));
+var import_langchain7 = require("langchain");
+async function globFiles(pattern, cwd, maxResults = 200, includeHidden = false) {
+  const rootDir = resolveWorkspacePath(cwd || ".");
+  const allFiles = await walkFiles(rootDir, { includeHidden, maxFiles: Math.max(maxResults * 20, 1e3) });
+  const normalizedPattern = normalizePathForMatch(pattern);
+  const matches = allFiles.map((file2) => normalizePathForMatch(import_path12.default.relative(rootDir, file2))).filter((relativePath) => matchesGlob(relativePath, normalizedPattern)).slice(0, maxResults);
+  return truncateOutput(formatJson({ cwd: rootDir, pattern, count: matches.length, files: matches }));
+}
+var globTool = (0, import_langchain7.tool)(
+  async ({ pattern, cwd, maxResults, includeHidden }) => globFiles(pattern, cwd, maxResults, includeHidden),
+  {
+    name: "glob_files",
+    description: "\u6309 glob \u6A21\u5F0F\u67E5\u627E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u4E0B\u7684\u6587\u4EF6\uFF0C\u4F8B\u5982 **/*.ts\u3001src/**/*.tsx\u3002\u9ED8\u8BA4\u5FFD\u7565\u9690\u85CF\u76EE\u5F55\u3001node_modules\u3001dist\u3001.git\u3002",
+    schema: external_exports.object({
+      pattern: external_exports.string().describe("glob \u6587\u4EF6\u5339\u914D\u6A21\u5F0F\uFF0C\u4F8B\u5982 **/*.ts \u6216 src/**/*.tsx"),
+      cwd: external_exports.string().optional().describe("\u641C\u7D22\u6839\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55"),
+      maxResults: external_exports.number().default(200).describe("\u6700\u5927\u8FD4\u56DE\u6570\u91CF"),
+      includeHidden: external_exports.boolean().default(false).describe("\u662F\u5426\u5305\u542B\u9690\u85CF\u6587\u4EF6\u6216\u9690\u85CF\u76EE\u5F55")
+    })
+  }
+);
+
+// src/agent/tools/grep.ts
+var import_fs_extra13 = __toESM(require("fs-extra"));
+var import_path13 = __toESM(require("path"));
+var import_langchain8 = require("langchain");
+async function grepFiles(query, cwd, includePattern = "**/*", isRegexp = false, maxResults = 100, includeHidden = false) {
+  const rootDir = resolveWorkspacePath(cwd || ".");
+  const matcher = isRegexp ? new RegExp(query, "i") : null;
+  const files = await walkFiles(rootDir, { includeHidden, maxFiles: Math.max(maxResults * 50, 1e3) });
+  const matches = [];
+  for (const file2 of files) {
+    if (matches.length >= maxResults) break;
+    const relativePath = normalizePathForMatch(import_path13.default.relative(rootDir, file2));
+    if (!matchesGlob(relativePath, includePattern) || !isProbablyTextFile(file2)) {
+      continue;
+    }
+    const content = await import_fs_extra13.default.readFile(file2, "utf-8").catch(() => "");
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+      const ok = matcher ? matcher.test(line) : line.toLowerCase().includes(query.toLowerCase());
+      if (ok) {
+        matches.push({ filePath: relativePath, line: index + 1, text: line.trim() });
+        if (matches.length >= maxResults) break;
+      }
+    }
+  }
+  return truncateOutput(formatJson({ cwd: rootDir, query, includePattern, count: matches.length, matches }));
+}
+var grepTool = (0, import_langchain8.tool)(
+  async ({ query, cwd, includePattern, isRegexp, maxResults, includeHidden }) => grepFiles(query, cwd, includePattern, isRegexp, maxResults, includeHidden),
+  {
+    name: "grep_files",
+    description: "\u5728\u6587\u672C\u6587\u4EF6\u4E2D\u641C\u7D22\u5185\u5BB9\uFF0C\u652F\u6301\u666E\u901A\u5B57\u7B26\u4E32\u6216\u6B63\u5219\u8868\u8FBE\u5F0F\uFF0C\u53EF\u7528 includePattern \u9650\u5B9A\u6587\u4EF6\u8303\u56F4\u3002",
+    schema: external_exports.object({
+      query: external_exports.string().describe("\u8981\u641C\u7D22\u7684\u5B57\u7B26\u4E32\u6216\u6B63\u5219\u8868\u8FBE\u5F0F"),
+      cwd: external_exports.string().optional().describe("\u641C\u7D22\u6839\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55"),
+      includePattern: external_exports.string().default("**/*").describe("\u9650\u5B9A\u641C\u7D22\u6587\u4EF6\u7684 glob \u6A21\u5F0F\uFF0C\u4F8B\u5982 src/**/*.ts"),
+      isRegexp: external_exports.boolean().default(false).describe("query \u662F\u5426\u4E3A\u6B63\u5219\u8868\u8FBE\u5F0F"),
+      maxResults: external_exports.number().default(100).describe("\u6700\u5927\u8FD4\u56DE\u5339\u914D\u6570\u91CF"),
+      includeHidden: external_exports.boolean().default(false).describe("\u662F\u5426\u5305\u542B\u9690\u85CF\u6587\u4EF6\u6216\u9690\u85CF\u76EE\u5F55")
+    })
+  }
+);
+
+// src/agent/tools/question.ts
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_langchain9 = require("langchain");
+async function askQuestion(question, type = "input", choices = []) {
+  const promptType = type === "select" ? "list" : type;
+  const answer = await import_inquirer2.default.prompt([
+    {
+      name: "value",
+      type: promptType,
+      message: question,
+      choices: type === "select" ? choices : void 0
+    }
+  ]);
+  const value = answer["value"];
+  return typeof value === "string" ? value : JSON.stringify(value);
 }
+var questionTool = (0, import_langchain9.tool)(
+  async ({ question, type, choices }) => askQuestion(question, type, choices),
+  {
+    name: "ask_question",
+    description: "\u5F53\u7EE7\u7EED\u4EFB\u52A1\u5FC5\u987B\u83B7\u53D6\u7528\u6237\u6F84\u6E05\u3001\u786E\u8BA4\u6216\u9009\u62E9\u65F6\uFF0C\u5411\u7528\u6237\u53D1\u8D77\u547D\u4EE4\u884C\u63D0\u95EE\u5E76\u8FD4\u56DE\u7B54\u6848\u3002\u4E0D\u8981\u8BE2\u95EE\u5BC6\u7801\u3001\u5BC6\u94A5\u7B49\u654F\u611F\u4FE1\u606F\u3002",
+    schema: external_exports.object({
+      question: external_exports.string().describe("\u8981\u8BE2\u95EE\u7528\u6237\u7684\u95EE\u9898"),
+      type: external_exports.enum(["input", "confirm", "select"]).default("input").describe("\u95EE\u9898\u7C7B\u578B\uFF1Ainput \u6587\u672C\u8F93\u5165\u3001confirm \u786E\u8BA4\u3001select \u5355\u9009"),
+      choices: external_exports.array(external_exports.string()).default([]).describe("select \u5355\u9009\u9879\u5217\u8868\uFF1B\u975E select \u7C7B\u578B\u53EF\u4E3A\u7A7A")
+    })
+  }
+);
+
+// src/agent/tools/read.ts
+var import_fs_extra14 = __toESM(require("fs-extra"));
+var import_iconv_lite2 = __toESM(require("iconv-lite"));
+var import_langchain10 = require("langchain");
+async function readFile2(filePath, startLine = 1, endLine = -1, encoding) {
+  const absPath = resolveWorkspacePath(filePath);
+  if (!await import_fs_extra14.default.pathExists(absPath)) {
+    return `Read error: \u6587\u4EF6\u4E0D\u5B58\u5728 ${absPath}`;
+  }
+  const stat = await import_fs_extra14.default.stat(absPath);
+  if (!stat.isFile()) {
+    return `Read error: \u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6 ${absPath}`;
+  }
+  const buffer = await import_fs_extra14.default.readFile(absPath);
+  const targetEncoding = encoding || getEncoding() || "utf-8";
+  const content = import_iconv_lite2.default.decode(buffer, targetEncoding === "auto" ? "utf-8" : targetEncoding);
+  const lines = content.split(/\r?\n/);
+  const safeStart = Math.max(1, startLine || 1);
+  const safeEnd = endLine && endLine > 0 ? Math.min(endLine, lines.length) : lines.length;
+  if (safeStart > safeEnd) {
+    return `Read error: \u884C\u53F7\u8303\u56F4\u65E0\u6548\uFF0C\u6587\u4EF6\u5171 ${lines.length} \u884C`;
+  }
+  const selected = lines.slice(safeStart - 1, safeEnd).map((line, index) => `${safeStart + index}: ${line}`).join("\n");
+  return truncateOutput(formatJson({ filePath: absPath, totalLines: lines.length, startLine: safeStart, endLine: safeEnd, content: selected }));
+}
+var readFileTool = (0, import_langchain10.tool)(
+  async ({ filePath, startLine, endLine, encoding }) => readFile2(filePath, startLine, endLine, encoding),
+  {
+    name: "read_file",
+    description: "\u8BFB\u53D6\u672C\u5730\u6587\u672C\u6587\u4EF6\u5185\u5BB9\u3002\u652F\u6301\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u8DEF\u5F84\uFF0C\u53EF\u6307\u5B9A\u8D77\u6B62\u884C\u53F7\uFF1B\u8FD4\u56DE\u5E26\u884C\u53F7\u7684\u5185\u5BB9\u3002",
+    schema: external_exports.object({
+      filePath: external_exports.string().describe("\u8981\u8BFB\u53D6\u7684\u6587\u4EF6\u8DEF\u5F84\uFF0C\u652F\u6301\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u8DEF\u5F84"),
+      startLine: external_exports.number().default(1).describe("\u8D77\u59CB\u884C\u53F7\uFF0C\u9ED8\u8BA4 1"),
+      endLine: external_exports.number().default(-1).describe("\u7ED3\u675F\u884C\u53F7\uFF0C-1 \u8868\u793A\u8BFB\u53D6\u5230\u6587\u4EF6\u672B\u5C3E"),
+      encoding: external_exports.string().optional().describe("\u6587\u4EF6\u7F16\u7801\uFF0C\u4F8B\u5982 utf-8\u3001gbk\uFF1B\u4E0D\u586B\u5219\u4F7F\u7528\u5168\u5C40\u7F16\u7801\u914D\u7F6E")
+    })
+  }
+);
+
+// src/agent/tools/semanticMemory.ts
+var import_fs_extra15 = __toESM(require("fs-extra"));
+var import_path14 = __toESM(require("path"));
+var import_langchain11 = require("langchain");
+var DEFAULT_MEMORY_MARKDOWN = `# \u7528\u6237\u8BED\u4E49\u8BB0\u5FC6
+
+> \u8BE5\u6587\u4EF6\u7531\u8BED\u4E49\u8BB0\u5FC6\u5DE5\u5177\u7EF4\u62A4\u3002\u4EC5\u8BB0\u5F55\u53EF\u957F\u671F\u590D\u7528\u7684\u7528\u6237\u4FE1\u606F\u3001\u4E60\u60EF\u548C\u504F\u597D\uFF1B\u4E0D\u8981\u8BB0\u5F55\u5BC6\u7801\u3001\u5BC6\u94A5\u3001\u4EE4\u724C\u7B49\u654F\u611F\u4FE1\u606F\u3002
+
+## \u7528\u6237\u79F0\u547C
+
+## \u64CD\u4F5C\u4E60\u60EF
+
+## \u7F16\u7801\u4E60\u60EF
+
+## \u4E2A\u4EBA\u504F\u597D
+
+## \u5176\u4ED6\u957F\u671F\u8BB0\u5FC6
+`;
+function getMemoryFilePath(runtimeMemoryFilePath) {
+  return typeof runtimeMemoryFilePath === "string" && runtimeMemoryFilePath.trim() ? runtimeMemoryFilePath : void 0;
+}
+async function readSemanticMemory(memoryFilePath) {
+  if (!memoryFilePath) {
+    return "Semantic memory error: \u5F53\u524D\u8FD0\u884C\u4E0A\u4E0B\u6587\u672A\u63D0\u4F9B memoryFilePath\uFF0C\u65E0\u6CD5\u8BFB\u53D6\u7528\u6237\u8BED\u4E49\u8BB0\u5FC6";
+  }
+  if (!await import_fs_extra15.default.pathExists(memoryFilePath)) {
+    return DEFAULT_MEMORY_MARKDOWN;
+  }
+  return import_fs_extra15.default.readFile(memoryFilePath, "utf-8");
+}
+async function updateSemanticMemory(memoryFilePath, content) {
+  if (!memoryFilePath) {
+    return "Semantic memory error: \u5F53\u524D\u8FD0\u884C\u4E0A\u4E0B\u6587\u672A\u63D0\u4F9B memoryFilePath\uFF0C\u65E0\u6CD5\u66F4\u65B0\u7528\u6237\u8BED\u4E49\u8BB0\u5FC6";
+  }
+  await import_fs_extra15.default.ensureDir(import_path14.default.dirname(memoryFilePath));
+  await import_fs_extra15.default.writeFile(memoryFilePath, `${content.trim()}
+`, "utf-8");
+  return `\u5DF2\u66F4\u65B0\u7528\u6237\u8BED\u4E49\u8BB0\u5FC6: ${memoryFilePath}`;
+}
+var readSemanticMemoryTool = (0, import_langchain11.tool)(
+  async (_input, runtime) => {
+    return readSemanticMemory(getMemoryFilePath(runtime.context?.memoryFilePath));
+  },
+  {
+    name: "read_user_semantic_memory",
+    description: "\u8BFB\u53D6\u5F53\u524D\u7528\u6237\u8BED\u4E49\u8BB0\u5FC6 Markdown \u6587\u4EF6\u3002\u51C6\u5907\u65B0\u589E\u3001\u4FEE\u6B63\u6216\u5408\u5E76\u7528\u6237\u957F\u671F\u504F\u597D\u524D\uFF0C\u5E94\u5148\u8C03\u7528\u672C\u5DE5\u5177\u8BFB\u53D6\u73B0\u6709\u5185\u5BB9\uFF0C\u907F\u514D\u91CD\u590D\u548C\u8986\u76D6\u5DF2\u6709\u4FE1\u606F\u3002\u82E5\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u4F1A\u8FD4\u56DE\u63A8\u8350\u7684 Markdown \u6A21\u677F\u3002",
+    schema: external_exports.object({})
+  }
+);
+var updateSemanticMemoryTool = (0, import_langchain11.tool)(
+  async ({ content }, runtime) => {
+    return updateSemanticMemory(getMemoryFilePath(runtime.context?.memoryFilePath), content);
+  },
+  {
+    name: "update_user_semantic_memory",
+    description: "\u8986\u76D6\u66F4\u65B0\u5F53\u524D\u7528\u6237\u8BED\u4E49\u8BB0\u5FC6 Markdown \u6587\u4EF6\u3002content \u5FC5\u987B\u662F\u5B8C\u6574\u7684 Markdown \u6587\u4EF6\u5185\u5BB9\uFF0C\u800C\u4E0D\u662F\u7247\u6BB5\u3002\u4EC5\u8BB0\u5F55\u660E\u786E\u3001\u7A33\u5B9A\u3001\u53EF\u957F\u671F\u590D\u7528\u7684\u4FE1\u606F\uFF0C\u4F8B\u5982\u7528\u6237\u79F0\u547C\u3001\u64CD\u4F5C\u4E60\u60EF\u3001\u7F16\u7801\u4E60\u60EF\u3001\u4E2A\u4EBA\u504F\u597D\u7B49\uFF1B\u4E0D\u8981\u8BB0\u5F55\u4E00\u6B21\u6027\u4EFB\u52A1\u4FE1\u606F\u3001\u4E34\u65F6\u4E0A\u4E0B\u6587\u3001\u63A8\u6D4B\u5185\u5BB9\u3001\u5BC6\u7801\u3001\u5BC6\u94A5\u3001\u4EE4\u724C\u3001\u9690\u79C1\u654F\u611F\u4FE1\u606F\u3002\u66F4\u65B0\u524D\u5E94\u5148\u8C03\u7528 read_user_semantic_memory \u8BFB\u53D6\u73B0\u6709\u5185\u5BB9\uFF0C\u7136\u540E\u5728\u4FDD\u7559\u5DF2\u6709\u6709\u6548\u8BB0\u5FC6\u7684\u57FA\u7840\u4E0A\u5408\u5E76\u65B0\u4FE1\u606F\uFF0C\u6309 Markdown \u6807\u9898\u548C\u5217\u8868\u6574\u7406\uFF0C\u5E76\u81EA\u884C\u53BB\u91CD\u3002",
+    schema: external_exports.object({
+      content: external_exports.string().describe("\u5B8C\u6574\u7684\u7528\u6237\u8BED\u4E49\u8BB0\u5FC6 Markdown \u5185\u5BB9\uFF0C\u9700\u4FDD\u7559\u5E76\u5408\u5E76\u5DF2\u6709\u6709\u6548\u8BB0\u5FC6\uFF0C\u6309\u5206\u7C7B\u6807\u9898\u548C\u5217\u8868\u9879\u7EC4\u7EC7")
+    })
+  }
+);
+var semanticMemoryTools = [readSemanticMemoryTool, updateSemanticMemoryTool];
 
 // src/cli/cli-utils/TaskQueue.ts
 var import_crypto3 = require("crypto");
 var import_dayjs = __toESM(require("dayjs"));
-var import_fs_extra10 = __toESM(require("fs-extra"));
+var import_fs_extra16 = __toESM(require("fs-extra"));
 var TaskQueue = class {
   taskFilePath;
   constructor(agent) {
@@ -22034,11 +25300,11 @@ var TaskQueue = class {
     this.updateTasks(taskList);
   }
   loadTasks() {
-    const tasks = import_fs_extra10.default.readJSONSync(this.taskFilePath, { throws: false }) || [];
+    const tasks = import_fs_extra16.default.readJSONSync(this.taskFilePath, { throws: false }) || [];
     return tasks;
   }
   updateTasks(tasks) {
-    import_fs_extra10.default.writeJSONSync(this.taskFilePath, tasks);
+    import_fs_extra16.default.writeJSONSync(this.taskFilePath, tasks);
   }
   clearTasks() {
     this.updateTasks([]);
@@ -22061,6 +25327,161 @@ var TaskQueue = class {
   }
 };
 
+// src/agent/tools/task.ts
+var import_langchain12 = require("langchain");
+function getCurrentTaskQueue(agentId) {
+  return agentId ? new TaskQueue(agentId) : null;
+}
+function manageTaskQueue(agentId, action, task, index) {
+  const queue = getCurrentTaskQueue(agentId);
+  if (!queue) {
+    return "Task error: \u672A\u627E\u5230\u5F53\u524D\u4F1A\u8BDD\uFF0C\u8BF7\u5148\u521B\u5EFA agent \u4F1A\u8BDD";
+  }
+  if (action === "list") {
+    return formatJson({ tasks: queue.loadTasks() });
+  }
+  if (action === "add") {
+    if (!task?.trim()) {
+      return "Task error: \u6DFB\u52A0\u4EFB\u52A1\u65F6 task \u4E0D\u80FD\u4E3A\u7A7A";
+    }
+    queue.pushTask(task.trim());
+    return `\u5DF2\u6DFB\u52A0\u4EFB\u52A1: ${task.trim()}`;
+  }
+  if (action === "delete") {
+    const tasks = queue.loadTasks();
+    const safeIndex = Number(index);
+    if (!Number.isInteger(safeIndex) || safeIndex < 1 || safeIndex > tasks.length) {
+      return `Task error: \u4EFB\u52A1\u5E8F\u53F7\u65E0\u6548\uFF0C\u5F53\u524D\u4EFB\u52A1\u6570 ${tasks.length}`;
+    }
+    const removed = tasks[safeIndex - 1];
+    queue.delTask(safeIndex - 1);
+    return `\u5DF2\u5220\u9664\u4EFB\u52A1: [${removed.createTime}] ${removed.taskStr}`;
+  }
+  queue.clearTasks();
+  return "\u5DF2\u6E05\u7A7A\u4EFB\u52A1\u961F\u5217";
+}
+var taskTool = (0, import_langchain12.tool)(
+  async ({ action, task, index }, runtime) => {
+    const agentId = runtime.context?.agentId || getAgentId();
+    return manageTaskQueue(agentId, action, task, index);
+  },
+  {
+    name: "manage_task_queue",
+    description: "\u7BA1\u7406\u5F53\u524D agent \u4F1A\u8BDD\u4EFB\u52A1\u961F\u5217\uFF1A\u67E5\u770B\u3001\u6DFB\u52A0\u540E\u7EED\u4EFB\u52A1\u3001\u5220\u9664\u6307\u5B9A\u4EFB\u52A1\u6216\u6E05\u7A7A\u4EFB\u52A1\u3002\u6DFB\u52A0\u7684\u4EFB\u52A1\u4F1A\u5728\u5F53\u524D\u4EFB\u52A1\u7ED3\u675F\u540E\u7EE7\u7EED\u6267\u884C\u3002",
+    schema: external_exports.object({
+      action: external_exports.enum(["list", "add", "delete", "clear"]).describe("\u4EFB\u52A1\u961F\u5217\u64CD\u4F5C"),
+      task: external_exports.string().optional().describe("action=add \u65F6\u8981\u6DFB\u52A0\u7684\u4EFB\u52A1\u5185\u5BB9"),
+      index: external_exports.number().optional().describe("action=delete \u65F6\u8981\u5220\u9664\u7684\u4EFB\u52A1\u5E8F\u53F7\uFF0C\u4ECE 1 \u5F00\u59CB")
+    })
+  }
+);
+
+// src/agent/tools/webfetch.ts
+var import_langchain13 = require("langchain");
+async function webFetch(url2, timeout = 3e4, maxLength = 6e4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url2, {
+      method: "GET",
+      headers: {
+        "user-agent": "deepfish-ai/agent-tool",
+        accept: "text/html,text/plain,application/json,application/xml,*/*"
+      },
+      signal: controller.signal
+    });
+    const contentType = response.headers.get("content-type") || "";
+    const text = await response.text();
+    return truncateOutput(
+      JSON.stringify(
+        {
+          url: url2,
+          status: response.status,
+          ok: response.ok,
+          contentType,
+          body: text
+        },
+        null,
+        2
+      ),
+      maxLength
+    );
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    return `Web fetch error: ${message}`;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var webFetchTool = (0, import_langchain13.tool)(
+  async ({ url: url2, timeout, maxLength }) => webFetch(url2, timeout, maxLength),
+  {
+    name: "web_fetch",
+    description: "\u901A\u8FC7 HTTP GET \u83B7\u53D6\u7F51\u9875\u3001\u63A5\u53E3\u6216\u8FDC\u7A0B\u6587\u672C\u5185\u5BB9\uFF0C\u5E76\u8FD4\u56DE\u72B6\u6001\u7801\u3001content-type \u548C\u54CD\u5E94\u6B63\u6587\u3002",
+    schema: external_exports.object({
+      url: external_exports.string().url().describe("\u8981\u8BF7\u6C42\u7684\u5B8C\u6574 URL\uFF0C\u4F8B\u5982 https://example.com"),
+      timeout: external_exports.number().default(3e4).describe("\u8BF7\u6C42\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09"),
+      maxLength: external_exports.number().default(6e4).describe("\u6700\u5927\u8FD4\u56DE\u5B57\u7B26\u6570\uFF0C\u8D85\u51FA\u4F1A\u622A\u65AD")
+    })
+  }
+);
+
+// src/agent/tools/write.ts
+var import_fs_extra17 = __toESM(require("fs-extra"));
+var import_path15 = __toESM(require("path"));
+var import_langchain14 = require("langchain");
+async function writeFile2(filePath, content, mode = "overwrite") {
+  const absPath = resolveWorkspacePath(filePath);
+  const exists = await import_fs_extra17.default.pathExists(absPath);
+  if (mode === "create" && exists) {
+    return `Write error: \u6587\u4EF6\u5DF2\u5B58\u5728\uFF0Ccreate \u6A21\u5F0F\u4E0D\u4F1A\u8986\u76D6 ${absPath}`;
+  }
+  await import_fs_extra17.default.ensureDir(import_path15.default.dirname(absPath));
+  if (mode === "append") {
+    await import_fs_extra17.default.appendFile(absPath, content, "utf-8");
+    return `\u5DF2\u8FFD\u52A0\u5199\u5165\u6587\u4EF6: ${absPath}`;
+  }
+  await import_fs_extra17.default.writeFile(absPath, content, "utf-8");
+  return `${exists ? "\u5DF2\u8986\u76D6\u5199\u5165\u6587\u4EF6" : "\u5DF2\u521B\u5EFA\u6587\u4EF6"}: ${absPath}`;
+}
+var writeFileTool = (0, import_langchain14.tool)(
+  async ({ filePath, content, mode }) => writeFile2(filePath, content, mode),
+  {
+    name: "write_file",
+    description: "\u5411\u672C\u5730\u6587\u4EF6\u5199\u5165\u6587\u672C\u5185\u5BB9\u3002\u53EF\u521B\u5EFA\u65B0\u6587\u4EF6\u3001\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\u6216\u8FFD\u52A0\u5185\u5BB9\uFF0C\u4F1A\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\u3002",
+    schema: external_exports.object({
+      filePath: external_exports.string().describe("\u76EE\u6807\u6587\u4EF6\u8DEF\u5F84\uFF0C\u652F\u6301\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u8DEF\u5F84"),
+      content: external_exports.string().describe("\u8981\u5199\u5165\u7684\u5B8C\u6574\u6587\u672C\u5185\u5BB9"),
+      mode: external_exports.enum(["overwrite", "append", "create"]).default("overwrite").describe("\u5199\u5165\u6A21\u5F0F\uFF1Aoverwrite \u8986\u76D6\u3001append \u8FFD\u52A0\u3001create \u4EC5\u65B0\u5EFA")
+    })
+  }
+);
+
+// src/agent/tools/index.ts
+var builtinTools = [
+  taskTool,
+  executeCommandTool,
+  readFileTool,
+  editFileTool,
+  writeFileTool,
+  globTool,
+  grepTool,
+  questionTool,
+  webFetchTool,
+  ...packageTools,
+  ...semanticMemoryTools,
+  ...learnTools
+];
+async function getTools() {
+  return [...builtinTools, ...await scanUserTools(), ...await scanUserMcp()];
+}
+
+// src/agent/skills/index.ts
+var import_path16 = __toESM(require("path"));
+function getSkills() {
+  return [...getRegisteredSkills(), import_path16.default.join(__dirname, "./view-learn-cache.md")];
+}
+
 // src/agent/AIAgent/index.ts
 var import_os3 = __toESM(require("os"));
 var AIAgent = class extends import_eventemitter_super.EventEmitterSuper {
@@ -22078,8 +25499,10 @@ var AIAgent = class extends import_eventemitter_super.EventEmitterSuper {
   memoryFilePath = "";
   sessionDirPath = "";
   userStorePath = "";
+  agentRulesPath = "";
   roomClient = null;
   taskQueue = {};
+  isPrintThinking = true;
   constructor(opt) {
     super();
     this.id = opt.id || `agent-${Date.now()}`;
@@ -22087,6 +25510,9 @@ var AIAgent = class extends import_eventemitter_super.EventEmitterSuper {
     this.workspace = opt.workspace;
     this.memoryFilePath = opt.memoryFilePath;
     this.sessionDirPath = opt.sessionDirPath;
+    this.userStorePath = opt.userStorePath;
+    this.agentRulesPath = opt.agentRulesPath;
+    this.isPrintThinking = opt.isPrintThinking;
     this.opt = opt;
   }
   async init() {
@@ -22098,73 +25524,110 @@ var AIAgent = class extends import_eventemitter_super.EventEmitterSuper {
     });
     const contextSchema = external_exports.object({
       agent_name: external_exports.string(),
-      encoding: external_exports.string()
+      encoding: external_exports.string(),
+      skills: external_exports.array(external_exports.string()).optional(),
+      memoryFilePath: external_exports.string().optional(),
+      agentId: external_exports.string().optional()
     });
-    const agent = (0, import_deepagents.createDeepAgent)({
+    const agent = (0, import_langchain15.createAgent)({
       model,
       checkpointer,
-      backend: new import_deepagents.FilesystemBackend({
-        rootDir: this.workspace,
-        virtualMode: false
-      }),
       tools: this.tools,
-      skills: this.skills,
       contextSchema,
       middleware: [
-        createAgentEventMiddleware(this)
+        createAgentEventMiddleware(this),
+        (0, import_langchain15.summarizationMiddleware)({
+          model,
+          trigger: { tokens: this.opt.modelOpt.maxContextLength || 1e5 },
+          keep: { messages: 50 }
+        }),
+        (0, import_langchain15.humanInTheLoopMiddleware)({
+          interruptOn: {
+            install_package: {
+              allowedDecisions: ["approve", "reject"]
+            },
+            readEmailTool: false
+          }
+        }),
+        (0, import_langchain15.todoListMiddleware)(),
+        (0, import_deepagents.createPatchToolCallsMiddleware)(),
+        (0, import_deepagents.createSubAgentMiddleware)({
+          defaultModel: model,
+          subagents: [
+            {
+              name: "subagent",
+              description: "This subagent can execute sub tasks.",
+              systemPrompt: subSystemPrompt(this.workspace, import_os3.default.platform(), this.skills),
+              tools: this.tools,
+              model,
+              middleware: []
+            }
+          ]
+        })
       ],
-      memory: [this.memoryFilePath],
-      systemPrompt: systemPrompt(this.workspace, import_os3.default.platform())
+      systemPrompt: systemPrompt(this.workspace, import_os3.default.platform(), this.skills, this.memoryFilePath, this.agentRulesPath)
     });
     this.agent = agent;
-    this.taskQueue = new TaskQueue(this);
+    this.taskQueue = new TaskQueue(this.id);
     this.initEvents();
   }
   async execute(input) {
-    const humanMessage = new import_langchain6.HumanMessage(input);
+    const humanMessage = new import_langchain15.HumanMessage(input);
     this.messages.push(humanMessage);
     const stream = await this.agent.stream(
       { messages: this.messages },
       {
         streamMode: ["messages"],
+        recursionLimit: 2e3,
         subgraphs: true,
         configurable: { thread_id: this.id },
-        context: { agent_name: "deepfish", encoding: this.opt.encoding }
+        context: { agent_name: "deepfish", encoding: this.opt.encoding, skills: this.skills, memoryFilePath: this.memoryFilePath, agentId: this.id }
       }
     );
     for await (const [_namespace, mode, data] of stream) {
       if (mode === "messages") {
-        this.emit("STREAM_CONTENT_OUTPUT" /* STREAM_CONTENT_OUTPUT */, data[0].content);
+        const message = data[0].additional_kwargs.reasoning_content;
+        this.emit("STREAM_CONTENT_OUTPUT" /* STREAM_CONTENT_OUTPUT */, message);
       }
     }
+    const newTask = this.taskQueue.getTask();
+    if (newTask) {
+      log(`[\u4EFB\u52A1\u961F\u5217] \u53D1\u73B0\u65B0\u4EFB\u52A1\uFF0C\u5373\u5C06\u6267\u884C: ${newTask.taskStr}`, "#7fded1");
+      await this.execute(newTask.taskStr);
+    }
   }
   initEvents() {
     const thinking = new Thinking();
     this.on("TASK_BEFORE" /* TASK_BEFORE */, () => {
-      thinking.init();
     });
     this.on("TASK_AFTER" /* TASK_AFTER */, (msg) => {
-      thinking.stop();
-      const newTask = this.taskQueue.getTask();
-      if (newTask) {
-        log(`[\u4EFB\u52A1\u961F\u5217] \u53D1\u73B0\u65B0\u4EFB\u52A1\uFF0C\u5373\u5C06\u6267\u884C: ${newTask.taskStr}`, "#7fded1");
-        this.execute(newTask.taskStr);
-      }
+      logInfo(msg);
     });
     this.on("MODEL_BEFORE" /* MODEL_BEFORE */, () => {
     });
     this.on("MODEL_AFTER" /* MODEL_AFTER */, () => {
+      if (this.isPrintThinking) {
+        thinking.stop();
+      }
       streamOutput("\n");
     });
     this.on("MODEL_ERROR" /* MODEL_ERROR */, (error51) => {
+      if (this.isPrintThinking) {
+        thinking.stop();
+      }
       logError(error51?.message + "\n" + error51?.stack);
     });
     this.on("STREAM_CONTENT_OUTPUT" /* STREAM_CONTENT_OUTPUT */, (content) => {
-      thinking.setStop(content);
-      if (!thinking.isThinking) {
-        if (typeof content === "string") {
+      if (this.isPrintThinking) {
+        if (content && typeof content === "string") {
           streamOutput(content, "#f2c97d");
         }
+      } else {
+        if (content && typeof content === "string") {
+          thinking.start();
+        } else {
+          thinking.stop();
+        }
       }
     });
     this.on("COMPRESS_MESSAGES_BEFORE" /* COMPRESS_MESSAGES_BEFORE */, (_currentLength) => {
@@ -22174,7 +25637,6 @@ var AIAgent = class extends import_eventemitter_super.EventEmitterSuper {
     this.on("NEW_MESSAGE" /* NEW_MESSAGE */, (_msg) => {
     });
     this.on("USE_TOOL_BEFORE" /* USE_TOOL_BEFORE */, (_toolId, funcName, _funcArgs) => {
-      thinking.stop();
       log(`[\u8C03\u7528\u5DE5\u5177] ${funcName}`, "#c2a654");
     });
     this.on("USE_TOOL_RETURN" /* USE_TOOL_RETURN */, (_toolId, funcName, toolContent) => {
@@ -22279,12 +25741,12 @@ var AgentRoomClient = class {
 };
 
 // src/cli/cli-core/serve.ts
-var import_path12 = __toESM(require("path"));
+var import_path17 = __toESM(require("path"));
 var import_pm2 = __toESM(require("pm2"));
 var PM2_APP_NAME = "deepfish-ai-server";
 function getPm2Config() {
   const port = getServePort();
-  const serverScript = import_path12.default.join(getCodePath(), "dist/serve/pm2-server");
+  const serverScript = import_path17.default.join(getCodePath(), "dist/serve/pm2-server");
   return {
     name: PM2_APP_NAME,
     script: serverScript,
@@ -22296,8 +25758,8 @@ function getPm2Config() {
     autorestart: true,
     watch: false,
     max_memory_restart: "1G",
-    error_file: import_path12.default.join(getCodePath(), "logs", "pm2-error.log"),
-    out_file: import_path12.default.join(getCodePath(), "logs", "pm2-out.log"),
+    error_file: import_path17.default.join(getCodePath(), "logs", "pm2-error.log"),
+    out_file: import_path17.default.join(getCodePath(), "logs", "pm2-out.log"),
     log_date_format: "YYYY-MM-DD HH:mm:ss Z"
   };
 }
@@ -22429,13 +25891,16 @@ async function initAgent(config2, skills) {
     memoryFilePath: userPath.memory,
     userStorePath: userPath.userStore,
     sessionDirPath: getSessionDirPath(id),
+    agentRulesPath: userPath.agentRules,
     maxBlockFileSize: config2.maxBlockFileSize,
     // Max chunk file size in KB; files exceeding this size need to be processed in chunks
     encoding: config2.encoding,
     // CLI encoding format, can be set to utf-8, gbk, etc., or left empty for auto-detection
     maxSubAgentCount: config2.maxSubAgentCount,
     // Maximum parallel sub-agent execution count, -1 means unlimited
-    skills
+    skills,
+    isPrintThinking: config2.isPrintThinking
+    // Whether to print intermediate information during AI thinking, default is true
   });
   await agent.init();
   return agent;
@@ -22528,20 +25993,20 @@ function removeSessionById(agentId) {
     return;
   }
   const sessionDir = getSessionPath(agentId);
-  import_fs_extra11.default.removeSync(sessionDir);
+  import_fs_extra18.default.removeSync(sessionDir);
   const sessionsPath = getSessionsPath();
-  const sessionsFilePath = import_path13.default.join(sessionsPath, "sessions.json");
-  if (!import_fs_extra11.default.pathExistsSync(sessionsFilePath)) {
+  const sessionsFilePath = import_path18.default.join(sessionsPath, "sessions.json");
+  if (!import_fs_extra18.default.pathExistsSync(sessionsFilePath)) {
     logSuccess("Current session history cleared");
     return;
   }
-  const content = import_fs_extra11.default.readFileSync(sessionsFilePath, "utf-8");
+  const content = import_fs_extra18.default.readFileSync(sessionsFilePath, "utf-8");
   const parsed = JSON.parse(content);
   const sessions = Array.isArray(parsed) ? parsed : [];
   const existingSessionIndex = sessions.findIndex((s) => s.id === agentId);
   if (existingSessionIndex !== -1) {
     sessions.splice(existingSessionIndex, 1);
-    import_fs_extra11.default.writeFileSync(sessionsFilePath, JSON.stringify(sessions, null, 2), "utf-8");
+    import_fs_extra18.default.writeFileSync(sessionsFilePath, JSON.stringify(sessions, null, 2), "utf-8");
   }
   logSuccess("Current session history cleared");
 }
@@ -22557,15 +26022,15 @@ function openSessionDir() {
 }
 function initSession() {
   const sessionsPath = getSessionsPath();
-  const sessionsFilePath = import_path13.default.join(sessionsPath, "sessions.json");
+  const sessionsFilePath = import_path18.default.join(sessionsPath, "sessions.json");
   let sessions = [];
-  if (import_fs_extra11.default.pathExistsSync(sessionsFilePath)) {
-    const content = import_fs_extra11.default.readFileSync(sessionsFilePath, "utf-8");
+  if (import_fs_extra18.default.pathExistsSync(sessionsFilePath)) {
+    const content = import_fs_extra18.default.readFileSync(sessionsFilePath, "utf-8");
     const parsed = JSON.parse(content);
     sessions = Array.isArray(parsed) ? parsed : [];
   } else {
-    import_fs_extra11.default.ensureDirSync(sessionsPath);
-    import_fs_extra11.default.writeFileSync(sessionsFilePath, "[]", "utf-8");
+    import_fs_extra18.default.ensureDirSync(sessionsPath);
+    import_fs_extra18.default.writeFileSync(sessionsFilePath, "[]", "utf-8");
   }
   const workspace = getWorkspacePath();
   const existingSession = sessions.find((s) => s.workspace === workspace);
@@ -22576,23 +26041,23 @@ function initSession() {
   const agentId = (0, import_crypto4.randomUUID)();
   const newSession = {
     id: agentId,
-    name: import_path13.default.basename(workspace),
+    name: import_path18.default.basename(workspace),
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     workspace
   };
   sessions.push(newSession);
-  import_fs_extra11.default.writeFileSync(sessionsFilePath, JSON.stringify(sessions, null, 2), "utf-8");
+  import_fs_extra18.default.writeFileSync(sessionsFilePath, JSON.stringify(sessions, null, 2), "utf-8");
   initSessionDir(newSession.id);
   return newSession;
 }
 function initSessionDir(agentId) {
   const sessionDir = getSessionPath(agentId);
-  import_fs_extra11.default.ensureDirSync(sessionDir);
+  import_fs_extra18.default.ensureDirSync(sessionDir);
   const mainSessionPath = `${sessionDir}/main-session/`;
   const mainMsgQueuePath = `${sessionDir}/main-msg-queue.json`;
-  import_fs_extra11.default.ensureDirSync(mainSessionPath);
-  import_fs_extra11.default.ensureFileSync(mainMsgQueuePath);
+  import_fs_extra18.default.ensureDirSync(mainSessionPath);
+  import_fs_extra18.default.ensureFileSync(mainMsgQueuePath);
 }
 function _getCurrentAIConfig(config2) {
   const currentModelName = config2.currentModel;
@@ -22607,11 +26072,11 @@ function _getCurrentAIConfig(config2) {
 }
 function getAgentId() {
   const sessionsPath = getSessionsPath();
-  const sessionsFilePath = import_path13.default.join(sessionsPath, "sessions.json");
-  if (!import_fs_extra11.default.pathExistsSync(sessionsFilePath)) {
+  const sessionsFilePath = import_path18.default.join(sessionsPath, "sessions.json");
+  if (!import_fs_extra18.default.pathExistsSync(sessionsFilePath)) {
     return;
   }
-  const content = import_fs_extra11.default.readFileSync(sessionsFilePath, "utf-8");
+  const content = import_fs_extra18.default.readFileSync(sessionsFilePath, "utf-8");
   const parsed = JSON.parse(content);
   const sessions = Array.isArray(parsed) ? parsed : [];
   const workspace = getWorkspacePath();
@@ -22639,12 +26104,12 @@ function handleSkillsLs() {
 async function handleSkillsAdd(name) {
   logInfo(`Adding skill: ${name}`);
   const workspace = getWorkspacePath();
-  const skillDir = import_path14.default.join(workspace, name);
-  if (!import_fs_extra12.default.existsSync(skillDir)) {
+  const skillDir = import_path19.default.join(workspace, name);
+  if (!import_fs_extra19.default.existsSync(skillDir)) {
     logError(`Skill directory does not exist: ${skillDir}`);
     return;
   }
-  const { scope } = await import_inquirer2.default.prompt([
+  const { scope } = await import_inquirer3.default.prompt([
     {
       type: "list",
       name: "scope",
@@ -22656,17 +26121,17 @@ async function handleSkillsAdd(name) {
     }
   ]);
   const homePath = getHomePath();
-  const globalSkillDir = import_path14.default.join(homePath, "skills");
-  const localSkillDir = import_path14.default.join(workspace, ".deepfish", "skills");
+  const globalSkillDir = import_path19.default.join(homePath, "skills");
+  const localSkillDir = import_path19.default.join(workspace, ".deepfish-ai", "skills");
   if (scope === "local") {
-    import_fs_extra12.default.ensureDirSync(localSkillDir);
+    import_fs_extra19.default.ensureDirSync(localSkillDir);
   } else {
-    import_fs_extra12.default.ensureDirSync(globalSkillDir);
+    import_fs_extra19.default.ensureDirSync(globalSkillDir);
   }
   const targetDir = scope === "local" ? localSkillDir : globalSkillDir;
-  const targetPath = import_path14.default.join(targetDir, name);
-  if (import_fs_extra12.default.existsSync(targetPath)) {
-    const { overwrite } = await import_inquirer2.default.prompt([
+  const targetPath = import_path19.default.join(targetDir, name);
+  if (import_fs_extra19.default.existsSync(targetPath)) {
+    const { overwrite } = await import_inquirer3.default.prompt([
       {
         type: "confirm",
         name: "overwrite",
@@ -22678,9 +26143,9 @@ async function handleSkillsAdd(name) {
       logWarning("Add cancelled");
       return;
     }
-    import_fs_extra12.default.removeSync(targetPath);
+    import_fs_extra19.default.removeSync(targetPath);
   }
-  import_fs_extra12.default.moveSync(skillDir, targetPath, { overwrite: true });
+  import_fs_extra19.default.moveSync(skillDir, targetPath, { overwrite: true });
   logSuccess(`Skill ${scope === "local" ? "locally" : "globally"} added: ${targetPath}`);
   _updateRegister(targetDir);
 }
@@ -22692,13 +26157,13 @@ function handleSkillsDel(index) {
     return;
   }
   const skill = skills[skillIndex];
-  import_fs_extra12.default.removeSync(skill.skillPath);
+  import_fs_extra19.default.removeSync(skill.skillPath);
   const skillDir = skill.skillDir;
-  const registerPath = import_path14.default.join(skillDir, "skills", "register.json");
-  if (import_fs_extra12.default.existsSync(registerPath)) {
-    let register = import_fs_extra12.default.readJSONSync(registerPath);
+  const registerPath = import_path19.default.join(skillDir, "skills", "register.json");
+  if (import_fs_extra19.default.existsSync(registerPath)) {
+    let register = import_fs_extra19.default.readJSONSync(registerPath);
     register = register.filter((item) => item.skillPath !== skill.skillPath);
-    import_fs_extra12.default.writeJSONSync(registerPath, register, { spaces: 2 });
+    import_fs_extra19.default.writeJSONSync(registerPath, register, { spaces: 2 });
   }
   logSuccess(`Skill \u5220\u9664: ${skill.name}`);
 }
@@ -22712,8 +26177,8 @@ function handleSkillsEnable(index) {
   const skill = skills[skillIndex];
   skill.isEnabled = true;
   const skillDir = skill.skillDir;
-  const registerPath = import_path14.default.join(skillDir, "skills", "register.json");
-  import_fs_extra12.default.writeJSONSync(
+  const registerPath = import_path19.default.join(skillDir, "skills", "register.json");
+  import_fs_extra19.default.writeJSONSync(
     registerPath,
     skills.filter((item) => item.skillDir === skillDir),
     { spaces: 2 }
@@ -22730,8 +26195,8 @@ function handleSkillsDisable(index) {
   const skill = skills[skillIndex];
   skill.isEnabled = false;
   const skillDir = skill.skillDir;
-  const registerPath = import_path14.default.join(skillDir, "skills", "register.json");
-  import_fs_extra12.default.writeJSONSync(
+  const registerPath = import_path19.default.join(skillDir, "skills", "register.json");
+  import_fs_extra19.default.writeJSONSync(
     registerPath,
     skills.filter((item) => item.skillDir === skillDir),
     { spaces: 2 }
@@ -22741,7 +26206,7 @@ function handleSkillsDisable(index) {
 function handleSkillsDir() {
   logInfo("Opening skills directory");
   const homePath = getHomePath();
-  const globalSkillDir = import_path14.default.join(homePath, "skills");
+  const globalSkillDir = import_path19.default.join(homePath, "skills");
   openDirectory(globalSkillDir);
 }
 async function handleSkillsGenerate(target) {
@@ -22756,7 +26221,7 @@ async function handleSkillsGenerate(target) {
   }
   const currentModelName = config2.currentModel;
   if (!currentModelName) {
-    logError("No AI model configured, please run ai model use <\u540D\u79F0>");
+    logError("No AI model configured, please run ai model use <name>");
     return;
   }
   try {
@@ -22765,7 +26230,7 @@ async function handleSkillsGenerate(target) {
       logError("Failed to start service, please check config or port availability");
       return;
     }
-    const generateSkillPath = import_path14.default.join(__dirname, "./generate-skill.md");
+    const generateSkillPath = import_path19.default.join(__dirname, "./generate-skill.md");
     const agent = await initAgent(config2, [generateSkillPath]);
     const prompt = `\u8BF7\u6839\u636E\u4EE5\u4E0B\u9700\u6C42\u751F\u6210\u4E00\u4E2ASkill\u6A21\u5757\uFF1A${target}
 
@@ -22783,13 +26248,13 @@ async function handleSkillsGenerate(target) {
 }
 function _scanSkills(skillsDir) {
   const skills = [];
-  if (import_fs_extra12.default.existsSync(skillsDir)) {
-    const files = import_fs_extra12.default.readdirSync(skillsDir);
+  if (import_fs_extra19.default.existsSync(skillsDir)) {
+    const files = import_fs_extra19.default.readdirSync(skillsDir);
     files.forEach((file2) => {
-      const filePath = import_path14.default.resolve(skillsDir, file2);
-      if (import_fs_extra12.default.statSync(filePath).isDirectory()) {
-        const skillMdPath = import_path14.default.resolve(filePath, "SKILL.md");
-        if (import_fs_extra12.default.existsSync(skillMdPath)) {
+      const filePath = import_path19.default.resolve(skillsDir, file2);
+      if (import_fs_extra19.default.statSync(filePath).isDirectory()) {
+        const skillMdPath = import_path19.default.resolve(filePath, "SKILL.md");
+        if (import_fs_extra19.default.existsSync(skillMdPath)) {
           skills.push(filePath);
         }
       }
@@ -22798,17 +26263,17 @@ function _scanSkills(skillsDir) {
   return skills;
 }
 function _updateRegister(skillsDir) {
-  const registerPath = import_path14.default.resolve(skillsDir, "register.json");
-  if (import_fs_extra12.default.existsSync(skillsDir) && !import_fs_extra12.default.existsSync(registerPath)) {
-    import_fs_extra12.default.writeJSONSync(registerPath, [], { spaces: 2 });
-  } else if (!import_fs_extra12.default.existsSync(skillsDir)) {
+  const registerPath = import_path19.default.resolve(skillsDir, "register.json");
+  if (import_fs_extra19.default.existsSync(skillsDir) && !import_fs_extra19.default.existsSync(registerPath)) {
+    import_fs_extra19.default.writeJSONSync(registerPath, [], { spaces: 2 });
+  } else if (!import_fs_extra19.default.existsSync(skillsDir)) {
     return;
   }
   const skills = _scanSkills(skillsDir);
-  let register = import_fs_extra12.default.readJSONSync(registerPath);
+  let register = import_fs_extra19.default.readJSONSync(registerPath);
   const newRegister = [];
   skills.forEach((skillPath) => {
-    const skillName = import_path14.default.basename(skillPath);
+    const skillName = import_path19.default.basename(skillPath);
     const existItem = register.find((item) => item.skillPath === skillPath);
     if (!existItem) {
       newRegister.push({
@@ -22821,16 +26286,16 @@ function _updateRegister(skillsDir) {
   });
   register = register.filter((item) => skills.includes(item.skillPath));
   register.push(...newRegister);
-  import_fs_extra12.default.writeJSONSync(registerPath, register, { spaces: 2 });
+  import_fs_extra19.default.writeJSONSync(registerPath, register, { spaces: 2 });
 }
 function getRegisteredSkills() {
   const scanPaths = getScanDirPaths();
   const skills = [];
   scanPaths.forEach((scanPath) => {
     _updateRegister(scanPath);
-    const registerPath = import_path14.default.join(scanPath, "skills", "register.json");
-    if (import_fs_extra12.default.existsSync(registerPath)) {
-      const register = import_fs_extra12.default.readJSONSync(registerPath);
+    const registerPath = import_path19.default.join(scanPath, "skills", "register.json");
+    if (import_fs_extra19.default.existsSync(registerPath)) {
+      const register = import_fs_extra19.default.readJSONSync(registerPath);
       register.forEach((item) => {
         if (item.isEnabled) {
           skills.push(item.skillPath);
@@ -22842,10 +26307,10 @@ function getRegisteredSkills() {
 }
 function _getSkillList(skillsDir) {
   let allSkills = [];
-  const registerPath = import_path14.default.join(skillsDir, "skills", "register.json");
-  if (import_fs_extra12.default.existsSync(registerPath)) {
+  const registerPath = import_path19.default.join(skillsDir, "skills", "register.json");
+  if (import_fs_extra19.default.existsSync(registerPath)) {
     _updateRegister(skillsDir);
-    const register = import_fs_extra12.default.readJSONSync(registerPath);
+    const register = import_fs_extra19.default.readJSONSync(registerPath);
     allSkills = allSkills.concat(register);
   }
   return allSkills;
@@ -22868,7 +26333,7 @@ function _getAllSkills() {
 function registerSkillsCommands(program) {
   const skills = program.command("skills");
   skills.command("ls").description("\u5217\u51FA\u6240\u6709\u6280\u80FD").action(handleSkillsLs);
-  skills.command("add <name>").description("\u6DFB\u52A0\u672C\u5730\u6280\u80FD\u76EE\u5F55\u6216 zip \u6587\u4EF6").action(handleSkillsAdd);
+  skills.command("add <name>").description("\u6DFB\u52A0\u672C\u5730\u6280\u80FD\u76EE\u5F55").action(handleSkillsAdd);
   skills.command("del <index>").description("\u6309\u7D22\u5F15\u5220\u9664\u6280\u80FD").action(handleSkillsDel);
   skills.command("enable <index>").description("\u6309\u7D22\u5F15\u542F\u7528\u6280\u80FD").action(handleSkillsEnable);
   skills.command("disable <index>").description("\u6309\u7D22\u5F15\u7981\u7528\u6280\u80FD").action(handleSkillsDisable);
@@ -22877,12 +26342,57 @@ function registerSkillsCommands(program) {
 }
 
 // src/cli/cli-core/tools.ts
-var import_path15 = __toESM(require("path"));
+var import_inquirer4 = __toESM(require("inquirer"));
+var import_fs_extra20 = __toESM(require("fs-extra"));
+var import_path20 = __toESM(require("path"));
 function handleToolsDir() {
   const toolsPath = getToolsPath();
   openDirectory(toolsPath);
   logSuccess("Tools directory opened");
 }
+async function handleToolsAdd(name) {
+  logInfo(`Adding tool: ${name}`);
+  const workspace = getWorkspacePath();
+  const toolDir = import_path20.default.join(workspace, name);
+  if (!import_fs_extra20.default.existsSync(toolDir)) {
+    logError(`Tool directory does not exist: ${toolDir}`);
+    return;
+  }
+  const { scope } = await import_inquirer4.default.prompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "Select tool scope:",
+      choices: [
+        { name: "Local (current workspace only)", value: "local" },
+        { name: "Global (available to all workspaces)", value: "global" }
+      ]
+    }
+  ]);
+  const homePath = getHomePath();
+  const globalToolDir = import_path20.default.join(homePath, "tools");
+  const localToolDir = import_path20.default.join(workspace, ".deepfish-ai", "tools");
+  const targetDir = scope === "local" ? localToolDir : globalToolDir;
+  const targetPath = import_path20.default.join(targetDir, name);
+  import_fs_extra20.default.ensureDirSync(targetDir);
+  if (import_fs_extra20.default.existsSync(targetPath)) {
+    const { overwrite } = await import_inquirer4.default.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `A tool named "${name}" already exists at the target location. Overwrite?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      logWarning("Add cancelled");
+      return;
+    }
+    import_fs_extra20.default.removeSync(targetPath);
+  }
+  import_fs_extra20.default.moveSync(toolDir, targetPath, { overwrite: true });
+  logSuccess(`Tool ${scope === "local" ? "locally" : "globally"} added: ${targetPath}`);
+}
 async function handleToolsGenerate(target) {
   if (!target.trim()) {
     logError('Please provide a tool description, e.g.: ai tools generate "a weather query tool"');
@@ -22904,7 +26414,7 @@ async function handleToolsGenerate(target) {
       logError("Failed to start service, please check config or port availability");
       return;
     }
-    const generateSkillPath = import_path15.default.join(__dirname, "./generate-tool.md");
+    const generateSkillPath = import_path20.default.join(__dirname, "./generate-tool.md");
     const agent = await initAgent(config2, [generateSkillPath]);
     const prompt = `Please use the "generate-tool" SKILL to generate a tool module according to the following requirements: ${target}
 
@@ -22924,6 +26434,7 @@ async function handleToolsGenerate(target) {
 function registerToolsCommands(program) {
   const tools = program.command("tools");
   tools.command("dir").description("\u6253\u5F00\u5DE5\u5177\u76EE\u5F55").action(handleToolsDir);
+  tools.command("add <name>").description("\u6DFB\u52A0\u672C\u5730\u5DE5\u5177\u76EE\u5F55").action(handleToolsAdd);
   tools.command("generate <target>").description("\u751F\u6210\u5DE5\u5177").action(handleToolsGenerate);
 }
 
@@ -23049,7 +26560,7 @@ function registerMcpCommands(program) {
 }
 
 // src/cli/cli-core/input.ts
-var import_fs_extra13 = __toESM(require("fs-extra"));
+var import_fs_extra21 = __toESM(require("fs-extra"));
 var readline = __toESM(require("readline"));
 async function handleInput(args) {
   const input = args.join(" ");
@@ -23059,14 +26570,14 @@ async function handleInput(args) {
   }
   try {
     const configPath = getConfigPath();
-    if (!import_fs_extra13.default.pathExistsSync(configPath)) {
+    if (!import_fs_extra21.default.pathExistsSync(configPath)) {
       logError("Config file not found, please run init first");
       return;
     }
     const config2 = getConfig();
     const currentModelName = config2.currentModel;
     if (!currentModelName) {
-      logError("No AI model configured, please run ai model use <\u540D\u79F0>");
+      logError("No AI model configured, please run ai model use <name>");
       return;
     }
     const isServerRunning2 = await testServer();
@@ -23096,14 +26607,14 @@ async function handleInput(args) {
 async function multiInput() {
   try {
     const configPath = getConfigPath();
-    if (!import_fs_extra13.default.pathExistsSync(configPath)) {
+    if (!import_fs_extra21.default.pathExistsSync(configPath)) {
       logError("Config file not found, please run init first");
       return;
     }
     const config2 = getConfig();
     const currentModelName = config2.currentModel;
     if (!currentModelName) {
-      logError("No AI model configured, please run ai model use <\u540D\u79F0>");
+      logError("No AI model configured, please run ai model use <name>");
       return;
     }
     const isServerRunning2 = await testServer();
@@ -23115,7 +26626,7 @@ async function multiInput() {
     const connResult = await connectAgentRoom(agent);
     if (!connResult.ok) {
       if (connResult.reason === "duplicate-id") {
-        logWarning(`[agent-room] agent "${agent.id}" is already running, task added to queue`);
+        logWarning(`[agent-room] agent "${agent.id}" is already running`);
         return null;
       } else {
         logWarning("[agent-room] agent-room service not detected, running in offline mode");
@@ -23166,7 +26677,7 @@ function registerInputCommand(program) {
 }
 
 // src/cli/cli-core/cache.ts
-var import_path16 = __toESM(require("path"));
+var import_path21 = __toESM(require("path"));
 var userCache2 = new UserCache();
 function resolveId(input) {
   const index = Number(input);
@@ -23200,7 +26711,7 @@ function handleCacheList() {
 function handleCacheEdit(input) {
   const id = resolveId(input);
   if (!id) return;
-  const filePath = import_path16.default.join(getUserStorePath(), `${id}.md`);
+  const filePath = import_path21.default.join(getUserStorePath(), `${id}.md`);
   editFile(filePath);
 }
 function handleCacheDel(input) {
@@ -23238,56 +26749,56 @@ function helpInformation() {
   return `Usage: ai [options] [command]
 
 Commands:
-  ai "xxx"
+  ai "xxx"                         \u76F4\u63A5\u5411 AI \u53D1\u8D77\u4E00\u6B21\u4EFB\u52A1\u6216\u5BF9\u8BDD
 
   # Configuration commands
-  ai config edit
-  ai config view
-  ai config reset
-  ai config dir
+  ai config edit                    \u6253\u5F00\u5168\u5C40\u914D\u7F6E\u6587\u4EF6\u8FDB\u884C\u7F16\u8F91
+  ai config view                    \u67E5\u770B\u5F53\u524D\u5168\u5C40\u914D\u7F6E\u5185\u5BB9
+  ai config reset                   \u91CD\u7F6E\u5168\u5C40\u914D\u7F6E\u4E3A\u9ED8\u8BA4\u503C
+  ai config dir                     \u6253\u5F00\u6216\u8F93\u51FA\u5168\u5C40\u914D\u7F6E\u76EE\u5F55
 
   # Model commands
-  ai models add
-  ai models ls
-  ai models use <name>
-  ai models del <name>
+  ai models add                     \u6DFB\u52A0\u4E00\u4E2A\u65B0\u7684\u6A21\u578B\u914D\u7F6E
+  ai models ls                      \u67E5\u770B\u5DF2\u914D\u7F6E\u7684\u6A21\u578B\u5217\u8868
+  ai models use <name>              \u5207\u6362\u5F53\u524D\u9ED8\u8BA4\u4F7F\u7528\u7684\u6A21\u578B
+  ai models del <name>              \u5220\u9664\u6307\u5B9A\u540D\u79F0\u7684\u6A21\u578B\u914D\u7F6E
 
   # Skill commands
-  ai skills ls
-  ai skills add <name>
-  ai skills del <index>
-  ai skills enable <name|index>
-  ai skills disable <name|index>
-  ai skills dir
-  ai skills generate xxx
+  ai skills ls                      \u67E5\u770B\u5DF2\u5B89\u88C5\u6216\u5DF2\u914D\u7F6E\u7684\u6280\u80FD\u5217\u8868
+  ai skills add <name>              \u6DFB\u52A0\u6307\u5B9A\u540D\u79F0\u7684\u6280\u80FD
+  ai skills del <index>             \u5220\u9664\u6307\u5B9A\u5E8F\u53F7\u7684\u6280\u80FD
+  ai skills enable <name|index>     \u542F\u7528\u6307\u5B9A\u540D\u79F0\u6216\u5E8F\u53F7\u7684\u6280\u80FD
+  ai skills disable <name|index>    \u7981\u7528\u6307\u5B9A\u540D\u79F0\u6216\u5E8F\u53F7\u7684\u6280\u80FD
+  ai skills dir                     \u6253\u5F00\u6216\u8F93\u51FA\u6280\u80FD\u76EE\u5F55
+  ai skills generate xxx            \u6839\u636E\u63CF\u8FF0\u751F\u6210\u4E00\u4E2A\u65B0\u7684\u6280\u80FD\u6A21\u677F
 
   # Tools commands
-  ai tools dir
-  ai tools generate xxx
+  ai tools dir                      \u6253\u5F00\u6216\u8F93\u51FA\u7528\u6237\u81EA\u5B9A\u4E49\u5DE5\u5177\u76EE\u5F55
+  ai tools generate xxx             \u6839\u636E\u63CF\u8FF0\u751F\u6210\u4E00\u4E2A\u65B0\u7684\u5DE5\u5177\u6A21\u677F
 
   # Session commands
-  ai session clear
-  ai session dir
+  ai session clear                  \u6E05\u7A7A\u5F53\u524D\u4F1A\u8BDD\u8BB0\u5F55
+  ai session dir                    \u6253\u5F00\u6216\u8F93\u51FA\u4F1A\u8BDD\u6570\u636E\u76EE\u5F55
   
   # Task commands
-  ai task ls
-  ai task add <task>
-  ai task del <index>
-  ai task clear
+  ai task ls                        \u67E5\u770B\u5F53\u524D\u4EFB\u52A1\u961F\u5217
+  ai task add <task>                \u5411\u4EFB\u52A1\u961F\u5217\u6DFB\u52A0\u4E00\u4E2A\u540E\u7EED\u4EFB\u52A1
+  ai task del <index>               \u5220\u9664\u6307\u5B9A\u5E8F\u53F7\u7684\u4EFB\u52A1
+  ai task clear                     \u6E05\u7A7A\u5F53\u524D\u4EFB\u52A1\u961F\u5217
   
   # MCP commands
-  ai mcp edit
+  ai mcp edit                       \u6253\u5F00 MCP \u914D\u7F6E\u6587\u4EF6\u8FDB\u884C\u7F16\u8F91
   
   # Serve commands
-  ai serve
-  ai serve start
-  ai serve stop
-  ai serve restart
+  ai serve                          \u542F\u52A8\u670D\u52A1\u6216\u8FDB\u5165\u670D\u52A1\u7BA1\u7406\u5165\u53E3
+  ai serve start                    \u542F\u52A8\u540E\u53F0\u670D\u52A1
+  ai serve stop                     \u505C\u6B62\u540E\u53F0\u670D\u52A1
+  ai serve restart                  \u91CD\u542F\u540E\u53F0\u670D\u52A1
   
   # Cache commands
-  ai cache ls
-  ai cache edit <index|id>
-  ai cache del <index|id>
+  ai cache ls                       \u67E5\u770B\u5DF2\u7F13\u5B58\u7684\u5B66\u4E60\u5185\u5BB9\u5217\u8868
+  ai cache edit <index|id>          \u7F16\u8F91\u6307\u5B9A\u5E8F\u53F7\u6216 ID \u7684\u7F13\u5B58\u5185\u5BB9
+  ai cache del <index|id>           \u5220\u9664\u6307\u5B9A\u5E8F\u53F7\u6216 ID \u7684\u7F13\u5B58\u5185\u5BB9
 `;
 }
 function registerHelpCommand(program) {