@lousy-agents/mcp 5.22.16 → 5.22.18

package/dist/mcp-server.js

@@ -61621,7 +61621,8 @@ const lockFiles = [
 	"npm-shrinkwrap.json",
 	"bun.lockb",
 	"bun.lock",
-	"deno.lock"
+	"deno.lock",
+	"upm.lock"
 ];
 const packageFiles = [
 	"package.json",
@@ -61855,11 +61856,27 @@ async function readGitConfig(dir, opts) {
 async function writeGitConfig(path, config) {
 	await writeFile(path, stringifyGitConfig(config));
 }
+const _unescapeGitSubsection = (name) => name.replaceAll(/\\(.)/g, "$1");
+const _escapeGitSubsection = (name) => name.replaceAll(/(["\\])/g, "\\$1");
+const _escapeINISection = (name) => name.replaceAll("\\", String.raw`\\`).replaceAll(".", String.raw`\.`);
+const _encodeINISection = (name) => encodeURIComponent(name).replaceAll(".", "%2E");
+const _decodeINISection = (name) => decodeURIComponent(name);
+const _isSubsection = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function parseGitConfig(ini) {
-	return parseINI(ini.replaceAll(/^\[(\w+) "(.+)"\]$/gm, "[$1.$2]"));
+	return parseINI(ini.replaceAll(/^\[(\w+) "(.*)"\]$/gm, (_, section, subsection) => `[${section}.${_escapeINISection(_unescapeGitSubsection(subsection))}]`));
 }
 function stringifyGitConfig(config) {
-	return stringifyINI(config).replaceAll(/^\[(\w+)\.(\w+)\]$/gm, "[$1 \"$2\"]");
+	const encoded = {};
+	for (const [section, value] of Object.entries(config)) {
+		if (!_isSubsection(value)) {
+			encoded[section] = value;
+			continue;
+		}
+		const entries = {};
+		for (const [key, subValue] of Object.entries(value)) entries[_isSubsection(subValue) ? _encodeINISection(key) : key] = subValue;
+		encoded[section] = entries;
+	}
+	return stringifyINI(encoded).replaceAll(/^\[(\w+)\.(.*)\]$/gm, (_, section, subsection) => `[${section} "${_escapeGitSubsection(_decodeINISection(subsection))}"]`);
 }
 
 
@@ -90330,8 +90347,12 @@ function encodeCharacterReference(code) {
 
 ;// CONCATENATED MODULE: ../../node_modules/unist-util-visit-parents/lib/color.node.js
 /**
+ * Color a string.
+ *
  * @param {string} d
+ *   Value.
  * @returns {string}
+ *   Colored value.
  */
 function color_node_color(d) {
   return '\u001B[33m' + d + '\u001B[39m'
@@ -90507,46 +90528,98 @@ function color_node_color(d) {
  *   List with one or two values, the first an action, the second an index.
  *
  * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult
- *   Any value that can be returned from a visitor.
+ *   Any value that can be returned from an enter visitor.
+ *
+ *   Like `VisitorResultExit`,
+ *   but `SKIP` can also be returned,
+ *   to not walk the children of the node,
+ *   and `ActionTuple` can be used to combine an action with an index.
+ *
+ * @typedef {Index | boolean | null | undefined | void} VisitorResultExit
+ *   Any value that can be returned from an exit visitor.
  */
 
 /**
  * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform the parent of node (the last of `ancestors`).
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of an ancestor still results in them being
- *   traversed.
+ *   Handle a node (matching `test`, if given) before its children.
+ *
+ *   Changes inside `node` are walked next.
+ *   Replacing or removing it is easier in `exit`.
+ *   When replacing or removing it here,
+ *   return `SKIP` (as otherwise its old children are walked),
+ *   or `[SKIP, index]` to continue with the node now at `index`.
+ *   Changing next siblings (in walk order) is fine;
+ *   changing previous siblings needs a new `Index`.
+ *   Removing an ancestor or changing its previous siblings is not supported.
  * @param {Visited} node
  *   Found node.
  * @param {Array<VisitedParents>} ancestors
  *   Ancestors of `node`.
+ * @param {number | undefined} index
+ *   Index of `node` in its parent (the last of `ancestors`),
+ *   or `undefined` for the tree itself.
  * @returns {VisitorResult}
  *   What to do next.
  *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
+ *   Like `VisitorExit`,
+ *   but `SKIP` can also be returned,
+ *   to not walk the children of `node`.
+ *   Passing a tuple back (`ActionTuple`) only makes sense as `[SKIP, Index]`.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [VisitedParents=UnistParent]
+ *   Ancestor type.
+ */
+
+/**
+ * @callback VisitorExit
+ *   Handle a node (matching `test`, if given) after its children.
  *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
+ *   Changes inside `node` are not walked,
+ *   which makes this a good place to change `node` based on its children,
+ *   or to replace or remove it.
+ *   When removing `node` or changing previous siblings (in walk order),
+ *   return a new `Index`.
+ *   Removing an ancestor or changing its previous siblings is not supported.
+ * @param {Visited} node
+ *   Found node.
+ * @param {Array<VisitedParents>} ancestors
+ *   Ancestors of `node`.
+ * @param {number | undefined} index
+ *   Index of `node` in its parent (the last of `ancestors`),
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResultExit}
+ *   What to do next.
+ *
+ *   `CONTINUE` (`true`, nothing) continues as normal,
+ *   `EXIT` (`false`) stops traversing,
+ *   and `Index` continues at that sibling.
  * @template {UnistNode} [Visited=UnistNode]
  *   Visited node type.
  * @template {UnistParent} [VisitedParents=UnistParent]
  *   Ancestor type.
  */
 
+/**
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [VisitedParents=UnistParent]
+ *   Ancestor type.
+ * @typedef Visitors
+ *   Handle nodes when entering and exiting them.
+ *   The `enter` visitor is optional while `exit` is required.
+ *
+ *   Pass an `enter` visitor directly to only handle nodes when entering them.
+ *
+ *   `enter` is called before children (if any) are walked and `exit` after that.
+ *   `exit` is still called when `enter` returns `SKIP`.
+ *   Both `enter` and `exit` are only called for nodes that match an optional `test`.
+ * @property {Visitor<Visited, VisitedParents> | null | undefined} [enter]
+ *   Handle a node before its children (optional).
+ * @property {VisitorExit<Visited, VisitedParents>} exit
+ *   Handle a node after its children.
+ */
+
 /**
  * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor
  *   Build a typed `Visitor` function from a tree and a test.
@@ -90558,6 +90631,17 @@ function color_node_color(d) {
  *   Test type.
  */
 
+/**
+ * @typedef {Visitors<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitors
+ *   Build typed `Visitors` from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parents`.
+ * @template {UnistNode} [Tree=UnistNode]
+ *   Tree type.
+ * @template {Test} [Check=Test]
+ *   Test type.
+ */
+
 
 
 
@@ -90576,6 +90660,7 @@ const EXIT = false
 
 /**
  * Do not traverse this node’s children.
+ * Only works when entering a node.
  */
 const SKIP = 'skip'
 
@@ -90583,10 +90668,13 @@ const SKIP = 'skip'
  * Visit nodes, with ancestral information.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -90595,29 +90683,72 @@ const SKIP = 'skip'
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check>} enter
+ *   Handle each node when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {Check} check
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
+ * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
+ * @returns {undefined}
+ *   Nothing.
+ *
+ * @overload
+ * @param {Tree} tree
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree>} enter
+ *   Handle each node when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitors<Tree>} visitors
+ *   Handle each node when exiting it, and optionally when entering it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} test
- *   `unist-util-is`-compatible test
- * @param {Visitor | boolean | null | undefined} [visitor]
- *   Handle each node.
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
  * @param {boolean | null | undefined} [reverse]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -90626,28 +90757,89 @@ const SKIP = 'skip'
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function visitParents(tree, test, visitor, reverse) {
+function visitParents(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  reverse
+) {
+  if (!tree || typeof tree !== 'object') {
+    throw new Error('Unexpected value `' + tree + '` for `tree`, expected node')
+  }
+
+  let preorder = true
   /** @type {Test} */
   let check
+  /** @type {Visitors | Visitor} */
+  let visitors
+  /** @type {Visitor | null | undefined} */
+  let enter
+  /** @type {VisitorExit | null | undefined} */
+  let exit
+
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
+  if (
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
+  ) {
+    check = /** @type {Test} */ (testOrEnterOrVisitors)
+    visitors = enterOrVisitorsOrReverse
+    if (reverse) preorder = false
+  }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitors | Visitor} */ (testOrEnterOrVisitors)
+    if (enterOrVisitorsOrReverse) preorder = false
+  }
 
-  if (typeof test === 'function' && typeof visitor !== 'function') {
-    reverse = visitor
-    // @ts-expect-error no visitor given, so `visitor` is test.
-    visitor = test
+  if (typeof visitors === 'function') {
+    enter = visitors
+  } else if (visitors && typeof visitors === 'object') {
+    if (visitors.enter === null || visitors.enter === undefined) {
+      // Empty.
+    } else if (typeof visitors.enter === 'function') {
+      enter = visitors.enter
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.enter +
+          '` for `visitors.enter`, expected optional visitor'
+      )
+    }
+
+    if (typeof visitors.exit === 'function') {
+      exit = visitors.exit
+    } else {
+      throw new Error(
+        'Unexpected value `' +
+          visitors.exit +
+          '` for `visitors.exit`, expected visitor (pass a visitor directly if you only want an enter visitor)'
+      )
+    }
   } else {
-    // @ts-expect-error visitor given, so `test` isn’t a visitor.
-    check = test
+    throw new Error(
+      'Unexpected value `' +
+        visitors +
+        '` for `enter` or `visitors`, expected visitor or object with visitors'
+    )
   }
 
   const is = convert(check)
-  const step = reverse ? -1 : 1
+  const step = preorder ? 1 : -1
 
   factory(tree, undefined, [])()
 
   /**
+   * Create a function to visit a node.
+   *
    * @param {UnistNode} node
+   *   Node to visit.
    * @param {number | undefined} index
+   *   Index of `node` in its parent.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @returns {() => Readonly<ActionTuple>}
+   *   Visit `node`.
    */
   function factory(node, index, parents) {
     const value = /** @type {Record<string, unknown>} */ (
@@ -90673,18 +90865,13 @@ function visitParents(tree, test, visitor, reverse) {
     return visit
 
     function visit() {
+      const matches =
+        !check || is(node, index, parents[parents.length - 1] || undefined)
       /** @type {Readonly<ActionTuple>} */
       let result = lib_empty
-      /** @type {Readonly<ActionTuple>} */
-      let subresult
-      /** @type {number} */
-      let offset
-      /** @type {Array<UnistParent>} */
-      let grandparents
 
-      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {
-        // @ts-expect-error: `visitor` is now a visitor.
-        result = toResult(visitor(node, parents))
+      if (enter && matches) {
+        result = toResult(enter(node, parents, index))
 
         if (result[0] === EXIT) {
           return result
@@ -90695,13 +90882,13 @@ function visitParents(tree, test, visitor, reverse) {
         const nodeAsParent = /** @type {UnistParent} */ (node)
 
         if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step
-          grandparents = parents.concat(nodeAsParent)
+          let offset = (preorder ? -1 : nodeAsParent.children.length) + step
+          const grandparents = [...parents, nodeAsParent]
 
           while (offset > -1 && offset < nodeAsParent.children.length) {
             const child = nodeAsParent.children[offset]
 
-            subresult = factory(child, offset, grandparents)()
+            const subresult = factory(child, offset, grandparents)()
 
             if (subresult[0] === EXIT) {
               return subresult
@@ -90713,6 +90900,23 @@ function visitParents(tree, test, visitor, reverse) {
         }
       }
 
+      if (exit && matches) {
+        const exitResult = toResult(exit(node, parents, index))
+
+        if (exitResult[0] === SKIP) {
+          throw new Error(
+            'Unexpected value `' +
+              exitResult[0] +
+              '` from `exit`, expected `CONTINUE`, `EXIT`, index, or nothing'
+          )
+        }
+
+        // Prefer a result from `exit` over `enter`.
+        if (exitResult[0] === EXIT || typeof exitResult[1] === 'number') {
+          return exitResult
+        }
+      }
+
       return result
     }
   }
@@ -90741,7 +90945,13 @@ function toResult(value) {
 ;// CONCATENATED MODULE: ../../node_modules/unist-util-visit/lib/index.js
 /**
  * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
- * @import {VisitorResult} from 'unist-util-visit-parents'
+ * @import {
+ *   InclusiveDescendant,
+ *   Matches,
+ *   Visitors as ParentsVisitors,
+ *   VisitorResult,
+ *   VisitorResultExit
+ * } from 'unist-util-visit-parents'
  */
 
 /**
@@ -90753,67 +90963,6 @@ function toResult(value) {
  *   which doesn’t work when publishing on npm.
  */
 
-// To do: use types from `unist-util-visit-parents` when it’s released.
-
-/**
- * @typedef {(
- *   Fn extends (value: any) => value is infer Thing
- *   ? Thing
- *   : Fallback
- * )} Predicate
- *   Get the value of a type guard `Fn`.
- * @template Fn
- *   Value; typically function that is a type guard (such as `(x): x is Y`).
- * @template Fallback
- *   Value to yield if `Fn` is not a type guard.
- */
-
-/**
- * @typedef {(
- *   Check extends null | undefined // No test.
- *   ? Value
- *   : Value extends {type: Check} // String (type) test.
- *   ? Value
- *   : Value extends Check // Partial test.
- *   ? Value
- *   : Check extends Function // Function test.
- *   ? Predicate<Check, Value> extends Value
- *     ? Predicate<Check, Value>
- *     : never
- *   : never // Some other test?
- * )} MatchesOne
- *   Check whether a node matches a primitive check in the type system.
- * @template Value
- *   Value; typically unist `Node`.
- * @template Check
- *   Value; typically `unist-util-is`-compatible test, but not arrays.
- */
-
-/**
- * @typedef {(
- *   Check extends ReadonlyArray<any>
- *   ? MatchesOne<Value, Check[number]>
- *   : MatchesOne<Value, Check>
- * )} Matches
- *   Check whether a node matches a check in the type system.
- * @template Value
- *   Value; typically unist `Node`.
- * @template Check
- *   Value; typically `unist-util-is`-compatible test.
- */
-
-/**
- * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
- *   Number; capped reasonably.
- */
-
-/**
- * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
- *   Increment a number in the type system.
- * @template {Uint} [I=0]
- *   Index.
- */
-
 /**
  * @typedef {(
  *   Node extends UnistParent
@@ -90839,89 +90988,64 @@ function toResult(value) {
  */
 
 /**
- * @typedef {(
- *   Depth extends Max
- *   ? never
- *   :
- *     | InternalParent<Node, Child>
- *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>
- * )} InternalAncestor
- *   Collect nodes in `Tree` that can be ancestors of `Child`.
- * @template {UnistNode} Node
- *   All node types in a tree.
- * @template {UnistNode} Child
- *   Node to search for.
- * @template {Uint} [Max=10]
- *   Max; searches up to this depth.
- * @template {Uint} [Depth=0]
- *   Current depth.
- */
-
-/**
- * @typedef {(
- *   Tree extends UnistParent
- *     ? Depth extends Max
- *       ? Tree
- *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
- *     : Tree
- * )} InclusiveDescendant
- *   Collect all (inclusive) descendants of `Tree`.
+ * @callback Visitor
+ *   Handle a node (matching `test`, if given) before its children.
  *
- *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
- *   > recurse without actually running into an infinite loop, which the
- *   > previous version did.
- *   >
- *   > Practically, a max of `2` is typically enough assuming a `Root` is
- *   > passed, but it doesn’t improve performance.
- *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
- *   > Using up to `10` doesn’t hurt or help either.
- * @template {UnistNode} Tree
- *   Tree type.
- * @template {Uint} [Max=10]
- *   Max; searches up to this depth.
- * @template {Uint} [Depth=0]
- *   Current depth.
+ *   Like `Visitor` in `unist-util-visit-parents`,
+ *   but with `index` and `parent` instead of `parents`.
+ * @param {Visited} node
+ *   Found node.
+ * @param {Visited extends UnistNode ? number | undefined : never} index
+ *   Index of `node` in `parent`,
+ *   or `undefined` for the tree itself.
+ * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
+ *   Parent of `node`,
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResult}
+ *   What to do next.
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [Ancestor=UnistParent]
+ *   Ancestor type.
  */
 
 /**
- * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform `parent`.
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
+ * @callback VisitorExit
+ *   Handle a node (matching `test`, if given) after its children.
  *
- *   Removing the children property of `parent` still results in them being
- *   traversed.
+ *   Like `VisitorExit` in `unist-util-visit-parents`,
+ *   but with `index` and `parent` instead of `parents`.
  * @param {Visited} node
  *   Found node.
  * @param {Visited extends UnistNode ? number | undefined : never} index
- *   Index of `node` in `parent`.
+ *   Index of `node` in `parent`,
+ *   or `undefined` for the tree itself.
  * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent
- *   Parent of `node`.
- * @returns {VisitorResult}
+ *   Parent of `node`,
+ *   or `undefined` for the tree itself.
+ * @returns {VisitorResultExit}
  *   What to do next.
- *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
- *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
  * @template {UnistNode} [Visited=UnistNode]
  *   Visited node type.
  * @template {UnistParent} [Ancestor=UnistParent]
  *   Ancestor type.
  */
 
+/**
+ * @template {UnistNode} [Visited=UnistNode]
+ *   Visited node type.
+ * @template {UnistParent} [Ancestor=UnistParent]
+ *   Ancestor type.
+ * @typedef Visitors
+ *   Handle nodes when entering and exiting them.
+ *
+ *   Like `Visitors` in `unist-util-visit-parents`.
+ * @property {Visitor<Visited, Ancestor> | null | undefined} [enter]
+ *   Handle a node before its children (optional).
+ * @property {VisitorExit<Visited, Ancestor>} exit
+ *   Handle a node after its children.
+ */
+
 /**
  * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch
  *   Build a typed `Visitor` function from a node and all possible parents.
@@ -90965,6 +91089,25 @@ function toResult(value) {
  *   Test type.
  */
 
+/**
+ * @typedef {(
+ *   Visitors<
+ *     Matches<InclusiveDescendant<Tree>, Check>,
+ *     Parent<
+ *       Extract<InclusiveDescendant<Tree>, UnistParent>,
+ *       Matches<InclusiveDescendant<Tree>, Check>
+ *     >
+ *   >
+ * )} BuildVisitors
+ *   Build typed `Visitors` from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parent`.
+ * @template {UnistNode} [Tree=UnistNode]
+ *   Node type.
+ * @template {Test} [Check=Test]
+ *   Test type.
+ */
+
 
 
 
@@ -90973,10 +91116,13 @@ function toResult(value) {
  * Visit nodes.
  *
  * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
+ * (**NLR**) or if `reverse` is given,
+ * in *reverse preorder* (**NRL**).
+ * An `exit` visitor is called in *postorder* (**LRN**)
+ * or if `reverse` is given, in *reverse postorder* (**RLN**).
  *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
+ * You can choose which nodes are visited by passing a `test`.
+ * For complex tests, you should test yourself in a visitor, as it will be
  * faster and will have improved type information.
  *
  * Walking the tree is an intensive task.
@@ -90985,29 +91131,48 @@ function toResult(value) {
  * to check if a node matches, and then perform different operations.
  *
  * You can change the tree.
- * See `Visitor` for more info.
+ * Changes inside a node made when entering it are walked,
+ * changes made when exiting it are not.
+ * See `Visitor` and `VisitorExit` for more info.
  *
  * @overload
  * @param {Tree} tree
+ *   Tree to traverse.
  * @param {Check} check
- * @param {BuildVisitor<Tree, Check>} visitor
+ *   `unist-util-is`-compatible test.
+ * @param {BuildVisitor<Tree, Check> | BuildVisitors<Tree, Check>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @overload
  * @param {Tree} tree
- * @param {BuildVisitor<Tree>} visitor
+ *   Tree to traverse.
+ * @param {BuildVisitor<Tree> | BuildVisitors<Tree>} visitors
+ *   Handle each node when entering it,
+ *   or `{enter, exit}` to also handle it when exiting it.
  * @param {boolean | null | undefined} [reverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
+ *   Nothing.
  *
  * @param {UnistNode} tree
  *   Tree to traverse.
- * @param {Visitor | Test} testOrVisitor
- *   `unist-util-is`-compatible test (optional, omit to pass a visitor).
- * @param {Visitor | boolean | null | undefined} [visitorOrReverse]
- *   Handle each node (when test is omitted, pass `reverse`).
- * @param {boolean | null | undefined} [maybeReverse=false]
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
+ * @param {Visitor | Visitors | Test} testOrEnterOrVisitors
+ *   `unist-util-is`-compatible test, `enter`, or `visitors`.
+ * @param {Visitor | Visitors | boolean | null | undefined} [enterOrVisitorsOrReverse]
+ *   `enter`, `visitors`, or `reverse` after a test.
+ * @param {boolean | null | undefined} [maybeReverse]
+ *   Walk children from last to first;
+ *   for `enter`, reverse preorder (NRL) instead of preorder (NLR);
+ *   for `exit`, reverse postorder (RLN) instead of postorder (LRN).
  * @returns {undefined}
  *   Nothing.
  *
@@ -91016,39 +91181,90 @@ function toResult(value) {
  * @template {Test} Check
  *   `unist-util-is`-compatible test.
  */
-function lib_visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+function lib_visit(
+  tree,
+  testOrEnterOrVisitors,
+  enterOrVisitorsOrReverse,
+  maybeReverse
+) {
+  /** @type {Test} */
+  let check
+  /** @type {Visitor | Visitors} */
+  let visitors
   /** @type {boolean | null | undefined} */
   let reverse
-  /** @type {Test} */
-  let test
-  /** @type {Visitor} */
-  let visitor
 
+  // Third parameter is an enter visitor or a visitors object, so expect a `test` too.
   if (
-    typeof testOrVisitor === 'function' &&
-    typeof visitorOrReverse !== 'function'
+    typeof enterOrVisitorsOrReverse === 'function' ||
+    (enterOrVisitorsOrReverse && typeof enterOrVisitorsOrReverse === 'object')
   ) {
-    test = undefined
-    visitor = testOrVisitor
-    reverse = visitorOrReverse
-  } else {
-    // @ts-expect-error: assume the overload with test was given.
-    test = testOrVisitor
-    // @ts-expect-error: assume the overload with test was given.
-    visitor = visitorOrReverse
+    check = /** @type {Test} */ (testOrEnterOrVisitors)
+    visitors = enterOrVisitorsOrReverse
     reverse = maybeReverse
   }
+  // Assume no test.
+  else {
+    visitors = /** @type {Visitor | Visitors} */ (testOrEnterOrVisitors)
+    reverse = enterOrVisitorsOrReverse
+  }
+
+  if (typeof visitors === 'function') {
+    visitParents(tree, check, lib_wrap(visitors), reverse)
+  } else {
+    visitParents(tree, check, wrapVisitors(visitors), reverse)
+  }
+}
+
+/**
+ * Turn `visit` visitors into `visitParents` visitors.
+ *
+ * @param {Visitors} visitors
+ *   Visitors for `visit`.
+ * @returns {ParentsVisitors}
+ *   Visitors for `visitParents`.
+ */
+function wrapVisitors(visitors) {
+  // Pass anything else straight to `visitParents` to get its errors.
+  if (!visitors || typeof visitors !== 'object') return visitors
+
+  return {
+    enter:
+      typeof visitors.enter === 'function'
+        ? lib_wrap(visitors.enter)
+        : visitors.enter,
+    exit:
+      typeof visitors.exit === 'function' ? lib_wrap(visitors.exit) : visitors.exit
+  }
+}
 
-  visitParents(tree, test, overload, reverse)
+/**
+ * Turn a `visit` visitor into a `visitParents` one.
+ *
+ * @template {VisitorResult} Result
+ *   Result type.
+ * @param {(node: UnistNode, index: number | undefined, parent: UnistParent | undefined) => Result} visitor
+ *   Visitor for `visit`.
+ * @returns {(node: UnistNode, parents: Array<UnistParent>, index: number | undefined) => Result}
+ *   Visitor for `visitParents`.
+ */
+function lib_wrap(visitor) {
+  return overload
 
   /**
+   * Call `visitor` with `index` and `parent` instead of `parents`.
+   *
    * @param {UnistNode} node
+   *   Visited node.
    * @param {Array<UnistParent>} parents
+   *   Ancestors of `node`.
+   * @param {number | undefined} index
+   *   Index of `node` in its parent.
+   * @returns {Result}
+   *   What to do next.
    */
-  function overload(node, parents) {
-    const parent = parents[parents.length - 1]
-    const index = parent ? parent.children.indexOf(node) : undefined
-    return visitor(node, index, parent)
+  function overload(node, parents, index) {
+    return visitor(node, index, parents[parents.length - 1])
   }
 }
 
@@ -94371,7 +94587,7 @@ function trough() {
 
       // Next or done.
       if (fn) {
-        lib_wrap(fn, next)(...output)
+        trough_lib_wrap(fn, next)(...output)
       } else {
         callback(null, ...output)
       }
@@ -94423,7 +94639,7 @@ function trough() {
  * @returns {Run}
  *   Wrapped middleware.
  */
-function lib_wrap(middleware, callback) {
+function trough_lib_wrap(middleware, callback) {
   /** @type {boolean} */
   let called
 
@@ -99769,22 +99985,30 @@ module.exports = __rspack_createRequire_require("zlib");
 4800(module, __unused_rspack_exports, __webpack_require__) {
 
 
-const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = __webpack_require__(5365)
+const { normalizeIPv6, removeDotSegments, removeDotSegmentsRelative, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = __webpack_require__(5365)
 const { SCHEMES, getSchemeHandler } = __webpack_require__(3956)
 
 const VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u
 const MALFORMED_SCHEME_ERROR = 'URI scheme is malformed.'
+const MALFORMED_HOST_ERROR = 'URI host is malformed.'
+// ASCII characters outside the RFC 3986 reg-name set (unreserved, sub-delims
+// and "%" for pct-encoded): C0 controls, space, DEL, and "#/:<>?@[\]^`{|}.
+const FORBIDDEN_DOMAIN_HOST_CHARACTER = /[\0-\x20"#/:<>?@[\\\]^`{|}\x7F]/u
 
 /**
+ * RFC 3986 section 3.1 does not allow percent-encoding in a scheme, so the
+ * scheme is validated as-is and never decoded. Decoding would let inert input
+ * such as `%6Aavascript:` become a live `javascript:` scheme.
+ *
  * @param {string} scheme
  * @returns {string}
  */
-function decodeValidScheme (scheme) {
-  const decodedScheme = unescape(String(scheme))
-  if (!VALID_SCHEME.test(decodedScheme)) {
+function validateScheme (scheme) {
+  const stringScheme = String(scheme)
+  if (!VALID_SCHEME.test(stringScheme)) {
     throw new TypeError(MALFORMED_SCHEME_ERROR)
   }
-  return decodedScheme
+  return stringScheme
 }
 
 /**
@@ -99845,6 +100069,12 @@ function resolve (baseURI, relativeURI, options) {
   const resolvedHost = resolved.host
   const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== '' &&
     (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6)
+  // Inputs are parsed scheme-neutrally, so delimiters and controls in a domain
+  // host are only detected here, once the final scheme is known. They always
+  // fail closed, including in percent-encoded hosts.
+  if (hasForbiddenDomainHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP)) {
+    throw new Error(MALFORMED_HOST_ERROR)
+  }
   canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP)
   // Percent escapes in an ASCII reg-name are encoded data. The WHATWG hostname
   // parser can reject them even though fast-uri preserves them safely as RFC
@@ -99902,14 +100132,17 @@ function resolveComponent (base, relative, options, skipNormalization) {
         if (relative.path[0] === '/') {
           target.path = removeDotSegments(relative.path)
         } else {
-          if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
+          const baseHasAuthority = base.userinfo !== undefined || base.host !== undefined || base.port !== undefined
+          if (baseHasAuthority && !base.path) {
             target.path = '/' + relative.path
           } else if (!base.path) {
             target.path = relative.path
           } else {
             target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path
           }
-          target.path = removeDotSegments(target.path)
+          target.path = base.scheme === undefined && !baseHasAuthority && target.path[0] !== '/'
+            ? removeDotSegmentsRelative(target.path)
+            : removeDotSegments(target.path)
         }
         target.query = relative.query
       }
@@ -99965,7 +100198,7 @@ function serialize (cmpts, opts) {
   const uriTokens = []
 
   if (component.scheme) {
-    component.scheme = decodeValidScheme(component.scheme)
+    component.scheme = validateScheme(component.scheme)
   }
 
   // find scheme handler
@@ -99975,7 +100208,11 @@ function serialize (cmpts, opts) {
   if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options)
 
   const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined
-  const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority
+  // A reference with no emitted scheme is path-noscheme: a bare ':' in its
+  // first path segment would reparse as a scheme (RFC 3986 3.3/4.2). Enforced
+  // under skipEscape too (resolve()), so the reapply below gates on this flag.
+  const schemelessReference = (component.scheme === undefined || options.reference === 'suffix') && !hasAuthority
+  const pathNoScheme = !options.skipEscape && schemelessReference
 
   if (component.path !== undefined) {
     if (!options.skipEscape) {
@@ -99987,7 +100224,7 @@ function serialize (cmpts, opts) {
 
   if (options.reference !== 'suffix' && component.scheme) {
     // Scheme handlers may replace the scheme during serialization.
-    component.scheme = decodeValidScheme(component.scheme)
+    component.scheme = validateScheme(component.scheme)
     uriTokens.push(component.scheme, ':')
   }
 
@@ -100007,13 +100244,18 @@ function serialize (cmpts, opts) {
     let s = component.path
 
     if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
-      s = removeDotSegments(s)
+      // A relative-path reference keeps its unresolvable leading ".." segments
+      // and must never become root-relative (RFC 3986 section 5.2.4 applies to
+      // merged target paths, not to the reference itself).
+      s = schemelessReference && s[0] !== '/'
+        ? removeDotSegmentsRelative(s)
+        : removeDotSegments(s)
     }
 
     // Dot-segment removal can expose a colon that was not originally in the
     // first segment (for example, "./a:b"). Reapply path-noscheme encoding so
     // the serialized relative reference cannot be reparsed as a URI scheme.
-    if (pathNoScheme) {
+    if (schemelessReference) {
       s = serializePathEncoding(s, true)
     }
 
@@ -100128,6 +100370,11 @@ function hasMalformedComponentPercentEncoding (matches) {
  * @returns {boolean} whether host conversion failed
  */
 function canonicalizeHost (parsed, options, schemeHandler, isIP) {
+  if (hasForbiddenDomainHost(parsed, options, schemeHandler, isIP)) {
+    parsed.error = parsed.error || MALFORMED_HOST_ERROR
+    return true
+  }
+
   if (
     !options.unicodeSupport &&
     (!schemeHandler || !schemeHandler.unicodeSupport) &&
@@ -100137,16 +100384,62 @@ function canonicalizeHost (parsed, options, schemeHandler, isIP) {
     isIP === false &&
     nonSimpleDomain(parsed.host)
   ) {
+    let url
     try {
-      parsed.host = new URL('http://' + parsed.host).hostname
+      url = new URL('http://' + parsed.host)
     } catch (e) {
       parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e
       return true
     }
+    // The WHATWG parser must have read the whole input as a host. Anything
+    // else means it found a delimiter fast-uri did not, so its hostname would
+    // describe a different authority.
+    if (!isHostOnlyURL(url)) {
+      parsed.error = parsed.error || MALFORMED_HOST_ERROR
+      return true
+    }
+    parsed.host = url.hostname
   }
   return false
 }
 
+/**
+ * Whether a domain host contains an ASCII character that RFC 3986 does not
+ * allow in a reg-name (unreserved, sub-delims, or pct-encoded). Such a host is
+ * rejected instead of being handed to the WHATWG URL parser, which would treat
+ * "@" as a userinfo delimiter (silently dropping the data before it) and strip
+ * TAB, LF, and CR. Non-ASCII characters remain allowed for IDNs.
+ *
+ * @param {import('./types/index').URIComponent} parsed
+ * @param {import('./types/index').Options} options
+ * @param {{ domainHost?: boolean }|undefined} schemeHandler
+ * @param {boolean} isIP
+ * @returns {boolean}
+ */
+function hasForbiddenDomainHost (parsed, options, schemeHandler, isIP) {
+  return Boolean(
+    parsed.host &&
+    isIP === false &&
+    !isIPLiteral(parsed.host) &&
+    (options.domainHost || (schemeHandler && schemeHandler.domainHost)) &&
+    FORBIDDEN_DOMAIN_HOST_CHARACTER.test(parsed.host)
+  )
+}
+
+/**
+ * @param {URL} url
+ * @returns {boolean}
+ */
+function isHostOnlyURL (url) {
+  return url.username === '' &&
+    url.password === '' &&
+    url.port === '' &&
+    url.pathname === '/' &&
+    url.search === '' &&
+    url.hash === '' &&
+    url.hostname !== ''
+}
+
 /**
  * @param {string} uri
  * @param {import('./types/index').Options} [opts]
@@ -100229,9 +100522,8 @@ function parseWithStatus (uri, opts) {
     parsed.fragment = matches[8]
 
     if (parsed.scheme !== undefined) {
-      const decodedScheme = unescape(parsed.scheme)
-      if (VALID_SCHEME.test(decodedScheme)) {
-        parsed.scheme = decodedScheme.toLowerCase()
+      if (VALID_SCHEME.test(parsed.scheme)) {
+        parsed.scheme = parsed.scheme.toLowerCase()
       } else {
         parsed.error = parsed.error || MALFORMED_SCHEME_ERROR
         malformedScheme = true
@@ -100265,7 +100557,7 @@ function parseWithStatus (uri, opts) {
         parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase()
 
         if (malformedIPLiteral) {
-          parsed.error = parsed.error || 'URI host is malformed.'
+          parsed.error = parsed.error || MALFORMED_HOST_ERROR
           malformedAuthorityOrPort = true
         }
       } else {
@@ -100302,7 +100594,11 @@ function parseWithStatus (uri, opts) {
         // pass only restores uppercase hex in escapes that remain encoded.
         host = normalizePercentEncoding(host.toLowerCase())
       }
-      parsed.host = reescapeHostDelimiters(host, isIP)
+      // Resolution parses both inputs with the internal `null` scheme before
+      // the effective scheme is known. Keep raw host delimiters for that step
+      // so resolve() can reject them for domain-host schemes; the resolved
+      // authority is encoded when it is serialized.
+      parsed.host = isIP || options.scheme !== 'null' ? reescapeHostDelimiters(host, isIP) : host
     }
 
     if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {
@@ -101025,6 +101321,57 @@ function removeDotSegments (path) {
   return output.join('')
 }
 
+/**
+ * Removes dot segments from the path of a relative reference (a path that does
+ * not start with "/") without changing what it resolves to against any base.
+ * Unlike `removeDotSegments`, leading ".." segments that cannot be collapsed
+ * are kept, the result never becomes root-relative, and a result that would be
+ * empty or start with an empty segment is prefixed with "." (an empty path
+ * means "same document" and a leading "//" would introduce an authority).
+ *
+ * @param {string} path
+ * @returns {string}
+ */
+function removeDotSegmentsRelative (path) {
+  if (path === '' || path[0] === '/') {
+    return removeDotSegments(path)
+  }
+
+  const segments = path.split('/')
+  const last = segments.length - 1
+  /** @type {string[]} */
+  const output = []
+  let trailingDirectory = false
+
+  for (let i = 0; i <= last; i++) {
+    const segment = segments[i]
+    if (segment === '.' || segment === '..') {
+      if (segment === '..') {
+        if (output.length !== 0 && output[output.length - 1] !== '..') {
+          output.pop()
+        } else {
+          output.push('..')
+        }
+      }
+      trailingDirectory = i === last
+    } else {
+      output.push(segment)
+    }
+  }
+
+  if (trailingDirectory && output[output.length - 1] !== '..') {
+    output.push('')
+  }
+  if (output.length === 0 || output[0] === '' || output[0].includes(':')) {
+    // An empty path, a leading empty segment ("//"), or a first segment
+    // containing ":" (which would be mistaken for a scheme, RFC 3986 section
+    // 4.2) must stay behind a "." segment so the reference keeps its meaning.
+    output.unshift('.')
+  }
+
+  return output.join('/')
+}
+
 /**
  * Re-escape RFC 3986 gen-delims that must not appear literally in the host.
  * After the URI regex parses, these characters cannot be literal in the host
@@ -101420,6 +101767,7 @@ module.exports = {
   encodeFragment,
   escapePreservingEscapes,
   removeDotSegments,
+  removeDotSegmentsRelative,
   isIPv4,
   isUUID,
   normalizeIPv6,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/mcp",
-    "version": "5.22.16",
+    "version": "5.22.18",
     "description": "MCP server for lousy-agents - provides AI coding assistant tools via the Model Context Protocol",
     "type": "module",
     "repository": {