@rockcarver/frodo-cli 4.0.0-24 → 4.0.0-26

package/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.0.0-25] - 2026-03-23
+
+## [4.0.0-24] - 2026-03-21
+
 ## [4.0.0-23] - 2026-03-21
 
 ## [4.0.0-22] - 2026-03-20
@@ -2209,7 +2213,9 @@ Frodo CLI 2.x automatically refreshes session and access tokens before they expi
 - Fixed problem with adding connection profiles
 - Miscellaneous bug fixes
 
-[unreleased]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-23...HEAD
+[unreleased]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-25...HEAD
+[4.0.0-25]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-24...v4.0.0-25
+[4.0.0-24]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-23...v4.0.0-24
 [4.0.0-23]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-22...v4.0.0-23
 [4.0.0-22]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-21...v4.0.0-22
 [4.0.0-21]: https://github.com/rockcarver/frodo-cli/compare/v4.0.0-20...v4.0.0-21

package/dist/app.cjs

@@ -238576,16 +238576,183 @@ var _repl = require('repl'); var _repl2 = _interopRequireDefault2(_repl);
 
 var _vm = require('vm'); var _vm2 = _interopRequireDefault2(_vm);
 
+// src/ops/ShellAutoCompleteOps.ts
+_chunkI43EENNMcjs.init_cjs_shims.call(void 0, );
+var CYAN = "\x1B[36m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+function getHelpMetadataFromInstance(frodoInstance) {
+  const candidate = frodoInstance["utils"];
+  if (!candidate || typeof candidate !== "object") return [];
+  const getHelpMetadata2 = candidate["getHelpMetadata"];
+  if (typeof getHelpMetadata2 !== "function") return [];
+  const result = getHelpMetadata2();
+  return Array.isArray(result) ? result : [];
+}
+function getValueAtPath(root4, pathSegments) {
+  let current = root4;
+  for (const segment of pathSegments) {
+    if (!current || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function normalizeName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function findBestDoc(methodName, moduleSegments, docsByMethod) {
+  const docs = _nullishCoalesce(docsByMethod.get(methodName), () => ( []));
+  if (docs.length === 0) return void 0;
+  const normalizedModuleSegments = moduleSegments.map(normalizeName);
+  const exactMatch = docs.find(
+    (d3) => normalizedModuleSegments.includes(normalizeName(d3.typeName))
+  );
+  return _nullishCoalesce(exactMatch, () => ( docs[0]));
+}
+function buildMethodScaffold(moduleSegments, methodName, docsByMethod) {
+  const doc = findBestDoc(methodName, moduleSegments, docsByMethod);
+  if (!doc) return "()";
+  const paramNames = (_nullishCoalesce(doc.params, () => ( []))).map((p) => p.name.trim()).filter((name) => name.length > 0);
+  if (paramNames.length === 0) return "()";
+  return `(${paramNames.join(", ")})`;
+}
+function abbrevType(type) {
+  const t = type.trim();
+  if (!t) return t;
+  if (t.includes("=>") || t.startsWith("(")) return "fn";
+  if (t.endsWith("[]")) return abbrevType(t.slice(0, -2)) + "[]";
+  switch (t) {
+    case "string":
+      return "str";
+    case "boolean":
+      return "bool";
+    case "number":
+      return "num";
+    default:
+      return t;
+  }
+}
+function buildHintLine(fullPath, doc) {
+  const params = (_nullishCoalesce(doc.params, () => ( []))).map((p) => {
+    const name = p.name.trim();
+    const type = abbrevType(p.type);
+    return name && type ? `${name}: ${type}` : name;
+  }).filter((s4) => s4.length > 0).join(", ");
+  return `\u25B8 ${CYAN}${fullPath}${RESET}(${DIM}${params}${RESET})`;
+}
+function createFrodoCompleter(rootBindings, docsByMethod, onMethodHint) {
+  return (line) => {
+    const invocationMatch = line.match(
+      /([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)\(\s*$/
+    );
+    if (invocationMatch) {
+      const fullPath = invocationMatch[1];
+      const parts = fullPath.split(".");
+      const rootName2 = parts[0];
+      const root5 = rootBindings[rootName2];
+      if (!root5) return [[], line];
+      const methodName = parts[parts.length - 1];
+      const parentSegments2 = parts.slice(1, -1);
+      const completion = `${fullPath}${buildMethodScaffold(
+        parentSegments2,
+        methodName,
+        docsByMethod
+      )}`;
+      if (onMethodHint) {
+        const doc = findBestDoc(methodName, parentSegments2, docsByMethod);
+        if (doc) {
+          setImmediate(() => onMethodHint(buildHintLine(fullPath, doc)));
+        }
+      }
+      return [[completion], `${fullPath}(`];
+    }
+    const tokenMatch = line.match(
+      /([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*\.?)$/
+    );
+    const token2 = _nullishCoalesce(_optionalChain([tokenMatch, 'optionalAccess', _580 => _580[1]]), () => ( ""));
+    if (!token2) return [[], line];
+    const rootCandidates = Object.keys(rootBindings).filter(
+      (rootName2) => rootName2.startsWith(token2)
+    );
+    if (!token2.includes(".")) {
+      const rootCompletions = rootCandidates.sort((a, b) => a.localeCompare(b));
+      return [rootCompletions, token2];
+    }
+    const segments = token2.split(".");
+    const rootName = segments[0];
+    const root4 = rootBindings[rootName];
+    if (!root4) return [[], token2];
+    const hasTrailingDot = token2.endsWith(".");
+    const parentSegments = hasTrailingDot ? segments.slice(1, -1) : segments.slice(1, -1);
+    const partial = hasTrailingDot ? "" : segments[segments.length - 1];
+    const targetObj = getValueAtPath(root4, parentSegments);
+    if (!targetObj || typeof targetObj !== "object") return [[], token2];
+    const completions = Object.keys(targetObj).filter((k2) => k2.startsWith(partial)).sort((a, b) => a.localeCompare(b)).map((k2) => {
+      const value = targetObj[k2];
+      const prefix = `${rootName}.${[...parentSegments, k2].join(".")}`;
+      if (typeof value !== "function") return prefix;
+      return `${prefix}${buildMethodScaffold(parentSegments, k2, docsByMethod)}`;
+    });
+    if (onMethodHint && completions.length === 1) {
+      const completion = completions[0];
+      const parenIdx = completion.indexOf("(");
+      if (parenIdx !== -1) {
+        const dotIdx = completion.lastIndexOf(".", parenIdx);
+        const resolvedMethodName = completion.slice(dotIdx + 1, parenIdx);
+        const doc = findBestDoc(
+          resolvedMethodName,
+          parentSegments,
+          docsByMethod
+        );
+        if (doc) {
+          const fullPath = completion.slice(0, parenIdx);
+          setImmediate(() => onMethodHint(buildHintLine(fullPath, doc)));
+        }
+      }
+    }
+    return [completions, token2];
+  };
+}
+function buildDocsByMethod(frodoInstance) {
+  const helpDocs = getHelpMetadataFromInstance(frodoInstance);
+  const docsByMethod = /* @__PURE__ */ new Map();
+  for (const doc of helpDocs) {
+    if (!docsByMethod.has(doc.methodName)) docsByMethod.set(doc.methodName, []);
+    docsByMethod.get(doc.methodName).push(doc);
+  }
+  return docsByMethod;
+}
+function registerOpenParenHint(replServer, rootBindings, docsByMethod, onHint) {
+  process.stdin.on("keypress", (_char, key) => {
+    const char = typeof _char === "string" ? _char : "";
+    const sequence = _nullishCoalesce(_optionalChain([key, 'optionalAccess', _581 => _581.sequence]), () => ( ""));
+    if (sequence !== "(" && char !== "(") return;
+    const currentLine = _nullishCoalesce(replServer["line"], () => ( ""));
+    const match2 = currentLine.match(
+      /([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)\s*$/
+    );
+    if (!match2) return;
+    const parts = match2[1].split(".");
+    if (!rootBindings[parts[0]]) return;
+    const methodName = parts[parts.length - 1];
+    const parentSegments = parts.slice(1, -1);
+    const doc = findBestDoc(methodName, parentSegments, docsByMethod);
+    if (doc) {
+      setImmediate(() => onHint(buildHintLine(match2[1], doc)));
+    }
+  });
+}
+
 // src/ops/ShellHelpOps.ts
 _chunkI43EENNMcjs.init_cjs_shims.call(void 0, );
 var BOLD = "\x1B[1m";
-var RESET = "\x1B[0m";
-var CYAN = "\x1B[36m";
+var RESET2 = "\x1B[0m";
+var CYAN2 = "\x1B[36m";
 var YELLOW = "\x1B[33m";
 var GREEN = "\x1B[32m";
-var DIM = "\x1B[2m";
+var DIM2 = "\x1B[2m";
 var cachedIndex = null;
-function getHelpMetadataFromInstance(frodoInstance) {
+function getHelpMetadataFromInstance2(frodoInstance) {
   const candidate = frodoInstance["utils"];
   if (!candidate || typeof candidate !== "object") return [];
   const getHelpMetadata2 = candidate["getHelpMetadata"];
@@ -238604,22 +238771,22 @@ function getMethodIndex(helpDocs) {
 }
 function formatMethodDoc(doc, verbose) {
   const lines = [];
-  lines.push(`${YELLOW}${doc.typeName}.${doc.methodName}${RESET}`);
-  lines.push(`  ${CYAN}Signature :${RESET} ${doc.signature}`);
+  lines.push(`${YELLOW}${doc.typeName}.${doc.methodName}${RESET2}`);
+  lines.push(`  ${CYAN2}Signature :${RESET2} ${doc.signature}`);
   if (doc.description) {
-    lines.push(`  ${CYAN}Description:${RESET} ${doc.description}`);
+    lines.push(`  ${CYAN2}Description:${RESET2} ${doc.description}`);
   }
   if (verbose) {
     if (doc.params.length > 0) {
-      lines.push(`  ${CYAN}Parameters :${RESET}`);
+      lines.push(`  ${CYAN2}Parameters :${RESET2}`);
       for (const p of doc.params) {
         const typePart = p.type ? `{${p.type}} ` : "";
         const desc = p.description ? `: ${p.description}` : "";
-        lines.push(`    ${typePart}${GREEN}${p.name}${RESET}${desc}`);
+        lines.push(`    ${typePart}${GREEN}${p.name}${RESET2}${desc}`);
       }
     }
     if (doc.returns) {
-      lines.push(`  ${CYAN}Returns    :${RESET} ${doc.returns}`);
+      lines.push(`  ${CYAN2}Returns    :${RESET2} ${doc.returns}`);
     }
   }
   return lines.join("\n");
@@ -238637,13 +238804,37 @@ function findModulePath(root4, target, prefix = "frodo") {
 }
 function createHelpContext(frodoInstance) {
   const alphaSort = (a, b) => a.localeCompare(b);
-  const metadata = getHelpMetadataFromInstance(frodoInstance);
+  const metadata = getHelpMetadataFromInstance2(frodoInstance);
   cachedIndex = null;
   function getMethodNames(obj) {
     return Object.keys(obj).filter(
       (k2) => typeof obj[k2] === "function"
     );
   }
+  function getSubModuleNames(obj) {
+    return Object.keys(obj).filter((k2) => {
+      const value = obj[k2];
+      return typeof value === "object" && value !== null;
+    });
+  }
+  function getCountParts(methodCount, subModuleCount) {
+    const parts = [];
+    if (methodCount > 0)
+      parts.push(`${methodCount} ${methodCount === 1 ? "method" : "methods"}`);
+    if (subModuleCount > 0)
+      parts.push(
+        `${subModuleCount} ${subModuleCount === 1 ? "module" : "modules"}`
+      );
+    return parts;
+  }
+  function formatCountSuffix(methodCount, subModuleCount) {
+    const parts = getCountParts(methodCount, subModuleCount);
+    return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+  }
+  function formatCountLabel(methodCount, subModuleCount) {
+    const parts = getCountParts(methodCount, subModuleCount);
+    return parts.length > 0 ? ` - ${parts.join(", ")}` : "";
+  }
   function help(target) {
     const idx = getMethodIndex(metadata);
     if (target === void 0) {
@@ -238656,42 +238847,39 @@ function createHelpContext(frodoInstance) {
       );
       const sortedFns = [...fns].sort(alphaSort);
       const sortedMods = [...mods].sort(alphaSort);
-      console.log(`${BOLD}${CYAN}Frodo Shell - Help System${RESET}`);
+      console.log(`${BOLD}${CYAN2}Frodo Shell - Help System${RESET2}`);
       console.log("");
+      console.log(`  ${GREEN}help()${RESET2}  ${DIM2}this overview${RESET2}`);
       console.log(
-        `  ${GREEN}help()${RESET}                                 -> this overview`
-      );
-      console.log(
-        `  ${GREEN}help(frodo.<sub-module>)${RESET}               -> list all methods in <sub-module>`
+        `  ${GREEN}help(frodo.<module>)${RESET2}  ${DIM2}list all methods and modules in <module>${RESET2}`
       );
       console.log(
-        `  ${GREEN}help(frodo.<sub-module>.<method name>)${RESET} -> full signature + docs for a method`
+        `  ${GREEN}help(frodo.<module>.<method>)${RESET2}  ${DIM2}full signature + docs for a method${RESET2}`
       );
       console.log(
-        `  ${GREEN}help("methodName")${RESET}                     -> search for a method across all modules`
+        `  ${GREEN}help("methodName")${RESET2}  ${DIM2}search for a method across all modules${RESET2}`
       );
       console.log("");
-      console.log(`${BOLD}Modules:${RESET}`);
+      const modulesCountLabel = sortedMods.length > 0 ? ` (${sortedMods.length} ${sortedMods.length === 1 ? "module" : "modules"})` : "";
+      console.log(`${BOLD}Modules${modulesCountLabel}:${RESET2}`);
       for (const k2 of sortedMods) {
         const val = frodoInstance[k2];
         if (typeof val === "object" && val !== null) {
-          const count = getMethodNames(val).length;
-          if (count > 0) {
-            console.log(
-              `  frodo.${GREEN}${k2}${RESET}  ${DIM}(${count} methods)${RESET}`
-            );
-          } else {
-            console.log(`  frodo.${GREEN}${k2}${RESET}`);
-          }
+          const methodCount = getMethodNames(val).length;
+          const subModuleCount = getSubModuleNames(val).length;
+          const countSuffix = formatCountSuffix(methodCount, subModuleCount);
+          console.log(
+            `  frodo.${GREEN}${k2}${RESET2}${countSuffix ? `  ${DIM2}${countSuffix}${RESET2}` : ""}`
+          );
         }
       }
       if (sortedFns.length > 0) {
         console.log("");
-        console.log(`${BOLD}Factory helpers:${RESET}`);
+        console.log(`${BOLD}Factory helpers:${RESET2}`);
         for (const fn of sortedFns) {
           const docs = idx.get(fn);
-          const sigHint = _optionalChain([docs, 'optionalAccess', _580 => _580.length]) ? `  ${DIM}${docs[0].signature}${RESET}` : "";
-          console.log(`  frodo.${GREEN}${fn}${RESET}${sigHint}`);
+          const sigHint = _optionalChain([docs, 'optionalAccess', _582 => _582.length]) ? `  ${DIM2}${docs[0].signature}${RESET2}` : "";
+          console.log(`  frodo.${GREEN}${fn}${RESET2}${sigHint}`);
         }
       }
       return;
@@ -238702,7 +238890,7 @@ function createHelpContext(frodoInstance) {
       const matches = idx.get(methodName);
       if (!matches || matches.length === 0) {
         console.log(
-          `${YELLOW}No documentation found for "${methodName}".${RESET}`
+          `${YELLOW}No documentation found for "${methodName}".${RESET2}`
         );
         return;
       }
@@ -238716,20 +238904,20 @@ function createHelpContext(frodoInstance) {
       const fnName = target.name;
       if (!fnName) {
         console.log(
-          `${YELLOW}Cannot determine function name from this reference.${RESET}`
+          `${YELLOW}Cannot determine function name from this reference.${RESET2}`
         );
         return;
       }
       const matches = idx.get(fnName);
       if (!matches || matches.length === 0) {
-        console.log(`${YELLOW}No documentation found for "${fnName}".${RESET}`);
+        console.log(`${YELLOW}No documentation found for "${fnName}".${RESET2}`);
         return;
       }
       if (matches.length === 1) {
         console.log(formatMethodDoc(matches[0], true));
       } else {
         console.log(
-          `${YELLOW}Found "${fnName}" in ${matches.length} module types:${RESET}`
+          `${YELLOW}Found "${fnName}" in ${matches.length} module types:${RESET2}`
         );
         for (const doc of matches) {
           console.log("");
@@ -238740,24 +238928,39 @@ function createHelpContext(frodoInstance) {
     }
     if (typeof target === "object" && target !== null) {
       const methods = getMethodNames(target);
-      const subMods = Object.keys(target).filter((k2) => {
-        const v = target[k2];
-        return typeof v === "object" && v !== null;
-      });
+      const subMods = getSubModuleNames(target);
       const sortedMethods = [...methods].sort(alphaSort);
       const sortedSubMods = [...subMods].sort(alphaSort);
+      const methodCount = sortedMethods.length;
+      const subModuleCount = sortedSubMods.length;
+      const moduleType = _optionalChain([findModulePath, 'call', _583 => _583(frodoInstance, target), 'optionalAccess', _584 => _584.replace, 'call', _585 => _585(
+        /^frodo\./,
+        ""
+      )]) || "Module";
+      console.log(
+        `${BOLD}${CYAN2}${moduleType}${formatCountLabel(methodCount, subModuleCount)}${RESET2}`
+      );
+      console.log("");
       if (sortedMethods.length === 0) {
         if (sortedSubMods.length > 0) {
-          console.log(`${BOLD}Sub-modules:${RESET}`);
+          console.log(
+            `${BOLD}Modules (${subModuleCount} ${subModuleCount === 1 ? "module" : "modules"}):${RESET2}`
+          );
           for (const subModule of sortedSubMods) {
-            console.log(`  ${GREEN}${subModule}${RESET}`);
+            const subModuleObj = target[subModule];
+            const subMethods = typeof subModuleObj === "object" && subModuleObj !== null ? getMethodNames(subModuleObj).length : 0;
+            const nestedSubMods = typeof subModuleObj === "object" && subModuleObj !== null ? getSubModuleNames(subModuleObj).length : 0;
+            const countSuffix = formatCountSuffix(subMethods, nestedSubMods);
+            console.log(
+              `  ${GREEN}${subModule}${RESET2}${countSuffix ? `  ${DIM2}${countSuffix}${RESET2}` : ""}`
+            );
           }
           const subModPath = _nullishCoalesce(findModulePath(frodoInstance, target), () => ( "frodo.X"));
           console.log(
-            `Use ${GREEN}help(${subModPath}.<sub-module>)${RESET} to explore further.`
+            `Use ${GREEN}help(${subModPath}.<module>)${RESET2} to explore further.`
           );
         } else {
-          console.log(`${YELLOW}No methods found on this object.${RESET}`);
+          console.log(`${YELLOW}No methods found on this object.${RESET2}`);
         }
         return;
       }
@@ -238776,39 +238979,47 @@ function createHelpContext(frodoInstance) {
         }
       }
       if (sortedSubMods.length > 0) {
-        console.log(`${BOLD}Sub-modules:${RESET}`);
+        console.log(
+          `${BOLD}Modules (${subModuleCount} ${subModuleCount === 1 ? "module" : "modules"}):${RESET2}`
+        );
         for (const subModule of sortedSubMods) {
-          console.log(`  ${GREEN}${subModule}${RESET}`);
+          const subModuleObj = target[subModule];
+          const subMethods = typeof subModuleObj === "object" && subModuleObj !== null ? getMethodNames(subModuleObj).length : 0;
+          const nestedSubMods = typeof subModuleObj === "object" && subModuleObj !== null ? getSubModuleNames(subModuleObj).length : 0;
+          const countSuffix = formatCountSuffix(subMethods, nestedSubMods);
+          console.log(
+            `  ${GREEN}${subModule}${RESET2}${countSuffix ? `  ${DIM2}${countSuffix}${RESET2}` : ""}`
+          );
         }
         console.log("");
       }
       console.log(
-        `${BOLD}${CYAN}${bestType || "Module"} - ${sortedMethods.length} method(s):${RESET}`
+        `${BOLD}${CYAN2}${bestType || moduleType}${formatCountLabel(methodCount, subModuleCount)}:${RESET2}`
       );
       console.log("");
       for (const methodName of sortedMethods) {
         const docs = idx.get(methodName);
-        const doc = _nullishCoalesce(_optionalChain([docs, 'optionalAccess', _581 => _581.find, 'call', _582 => _582((d3) => d3.typeName === bestType)]), () => ( _optionalChain([docs, 'optionalAccess', _583 => _583[0]])));
+        const doc = _nullishCoalesce(_optionalChain([docs, 'optionalAccess', _586 => _586.find, 'call', _587 => _587((d3) => d3.typeName === bestType)]), () => ( _optionalChain([docs, 'optionalAccess', _588 => _588[0]])));
         if (doc) {
           const sig = doc.signature.length > 100 ? doc.signature.slice(0, 97) + "..." : doc.signature;
-          console.log(`  ${YELLOW}${sig}${RESET}`);
+          console.log(`  ${YELLOW}${sig}${RESET2}`);
           if (doc.description) {
             const desc = doc.description.length > 110 ? doc.description.slice(0, 107) + "..." : doc.description;
-            console.log(`    ${DIM}${desc}${RESET}`);
+            console.log(`    ${DIM2}${desc}${RESET2}`);
           }
         } else {
-          console.log(`  ${YELLOW}${methodName}(...)${RESET}`);
+          console.log(`  ${YELLOW}${methodName}(...)${RESET2}`);
         }
         console.log("");
       }
       const modPath = _nullishCoalesce(findModulePath(frodoInstance, target), () => ( "frodo.X"));
       console.log(
-        `Tip: ${GREEN}help(${modPath}.<method name>)${RESET} shows full parameter documentation.`
+        `Tip: ${GREEN}help(${modPath}.<method name>)${RESET2} shows full parameter documentation.`
       );
       return;
     }
     console.log(
-      `${YELLOW}Usage: help() | help(frodo.<sub-module>) | help(frodo.<sub-module>.<method name>) | help("methodName")${RESET}`
+      `${YELLOW}Usage: help() | help(frodo.<module>) | help(frodo.<module>.<method name>) | help("methodName")${RESET2}`
     );
   }
   return { help };
@@ -238896,12 +239107,36 @@ var ShellHistory = class {
 };
 
 // src/cli/shell/shell.ts
+function printHintAbovePrompt(replServer, hint) {
+  if (!replServer) return;
+  setImmediate(() => {
+    process.stdout.write(`
+${hint}
+`);
+    const refreshLine = replServer._refreshLine;
+    if (typeof refreshLine === "function") {
+      refreshLine.call(replServer);
+      return;
+    }
+    replServer.displayPrompt(true);
+  });
+}
 async function startRepl(allowAwait = false, host) {
+  const docsByMethod = buildDocsByMethod(frodo);
+  const rootBindings = {
+    frodo,
+    frodoLib: frodo
+  };
+  let _replServer;
+  const completer = createFrodoCompleter(rootBindings, docsByMethod, (hint) => {
+    printHintAbovePrompt(_replServer, hint);
+  });
   const baseConfig = {
     prompt: "> ",
     ignoreUndefined: true,
     useGlobal: true,
     useColors: true,
+    completer,
     writer: function(output) {
       if (typeof output === "object" && output !== null) {
         return _util2.default.inspect(output, {
@@ -238919,11 +239154,15 @@ async function startRepl(allowAwait = false, host) {
       callback(null, await _vm2.default.runInNewContext(cmd, context));
     }
   };
-  const replServer = _repl2.default.start(allowAwait ? baseConfig : configWithoutAwait);
+  _replServer = _repl2.default.start(allowAwait ? baseConfig : configWithoutAwait);
+  const replServer = _replServer;
   replServer.context.frodoLib = frodo;
   replServer.context.frodo = frodo;
   const { help } = createHelpContext(frodo);
   replServer.context.help = help;
+  registerOpenParenHint(replServer, rootBindings, docsByMethod, (hint) => {
+    printHintAbovePrompt(replServer, hint);
+  });
   const shellHistory = new ShellHistory(host);
   replServer.history = shellHistory.getLines();
   replServer.defineCommand("history", {
@@ -238965,46 +239204,74 @@ async function startRepl(allowAwait = false, host) {
     help: "Show this help (frodo context + dot-commands)",
     action() {
       const BOLD2 = "\x1B[1m";
-      const RESET2 = "\x1B[0m";
-      const CYAN2 = "\x1B[36m";
+      const RESET3 = "\x1B[0m";
+      const CYAN3 = "\x1B[36m";
       const GREEN2 = "\x1B[32m";
-      const DIM2 = "\x1B[2m";
-      console.log(`${BOLD2}${CYAN2}Frodo Interactive Shell${RESET2}`);
+      const DIM3 = "\x1B[2m";
+      console.log(`${BOLD2}${CYAN3}Frodo Interactive Shell${RESET3}`);
       console.log("");
-      console.log(`${BOLD2}Explore the Frodo API:${RESET2}`);
+      console.log(`${BOLD2}Explore the Frodo API:${RESET3}`);
       console.log(
-        `  ${GREEN2}help()${RESET2}                          ${DIM2}browse all modules and methods${RESET2}`
+        `  ${GREEN2}help()${RESET3}  ${DIM3}browse all modules and methods${RESET3}`
       );
       console.log(
-        `  ${GREEN2}help(frodo.X)${RESET2}                   ${DIM2}list all methods in module X${RESET2}`
+        `  ${GREEN2}help(frodo.<module>)${RESET3}  ${DIM3}list all methods in module X${RESET3}`
       );
       console.log(
-        `  ${GREEN2}help(frodo.X.method)${RESET2}            ${DIM2}show full signature and docs${RESET2}`
+        `  ${GREEN2}help(frodo.<module>.<method>)${RESET3}  ${DIM3}show full signature and docs${RESET3}`
       );
       console.log(
-        `  ${GREEN2}help("methodName")${RESET2}              ${DIM2}search for a method across all modules${RESET2}`
+        `  ${GREEN2}help("methodName")${RESET3}  ${DIM3}search for a method across all modules${RESET3}`
       );
       console.log("");
-      console.log(`${BOLD2}Sample commands:${RESET2}`);
+      console.log(`${BOLD2}Sample commands:${RESET3}`);
       console.log(
-        `  ${GREEN2}frodo.info.getInfo()${RESET2}            ${DIM2}print info about the connected environment${RESET2}`
+        `  ${GREEN2}frodo.info.getInfo()${RESET3}  ${DIM3}print info about the connected environment${RESET3}`
       );
       console.log(
-        `  ${GREEN2}frodo.login.getTokens()${RESET2}         ${DIM2}get fresh or cached tokens${RESET2}`
+        `  ${GREEN2}frodo.login.getTokens()${RESET3}  ${DIM3}get fresh or cached tokens${RESET3}`
       );
       console.log(
-        `  ${GREEN2}frodo${RESET2}                           ${DIM2}show a hierarchy of all Frodo Library commands${RESET2}`
+        `  ${GREEN2}frodo${RESET3}  ${DIM3}show a hierarchy of all Frodo Library commands${RESET3}`
       );
       console.log("");
-      console.log(`${BOLD2}Shell dot-commands:${RESET2}`);
+      console.log(`${BOLD2}Shell dot-commands:${RESET3}`);
       const commands = replServer.commands;
       for (const name of Object.keys(commands).sort()) {
-        const helpText = _nullishCoalesce(_optionalChain([commands, 'access', _584 => _584[name], 'optionalAccess', _585 => _585.help]), () => ( ""));
-        console.log(`  ${GREEN2}.${name}${RESET2}  ${DIM2}${helpText}${RESET2}`);
+        const helpText = _nullishCoalesce(_optionalChain([commands, 'access', _589 => _589[name], 'optionalAccess', _590 => _590.help]), () => ( ""));
+        console.log(`  ${GREEN2}.${name}${RESET3}  ${DIM3}${helpText}${RESET3}`);
       }
       this.displayPrompt();
     }
   });
+  let historyNavigationActive = false;
+  process.stdin.on("keypress", (_char, key) => {
+    const rl = replServer;
+    const currentHistIdx = _nullishCoalesce(rl["_historyIndex"], () => ( -1));
+    if (_optionalChain([key, 'optionalAccess', _591 => _591.name]) === "down" && !historyNavigationActive && currentHistIdx === -1) {
+      const currentLine = _nullishCoalesce(replServer.line, () => ( ""));
+      if (currentLine.trim().length > 0) {
+        const replHistory = _nullishCoalesce(rl["history"], () => ( []));
+        if (replHistory[0] !== currentLine) {
+          replHistory.unshift(currentLine);
+          shellHistory.addLine(currentLine);
+        }
+        replServer.write(null, { ctrl: true, name: "e" });
+        replServer.write(null, { ctrl: true, name: "u" });
+      }
+    }
+    if (_optionalChain([key, 'optionalAccess', _592 => _592.name]) === "up" || _optionalChain([key, 'optionalAccess', _593 => _593.name]) === "down") {
+      historyNavigationActive = true;
+      return;
+    }
+    if (_optionalChain([key, 'optionalAccess', _594 => _594.name]) === "return" || _optionalChain([key, 'optionalAccess', _595 => _595.name]) === "enter") {
+      historyNavigationActive = false;
+      return;
+    }
+    if (_optionalChain([key, 'optionalAccess', _596 => _596.ctrl]) || _optionalChain([key, 'optionalAccess', _597 => _597.meta]) || typeof _optionalChain([key, 'optionalAccess', _598 => _598.name]) === "string") {
+      historyNavigationActive = false;
+    }
+  });
   replServer.on("line", (line) => {
     shellHistory.addLine(line);
   });
@@ -239407,7 +239674,7 @@ var compareVersions = (v12, v2) => {
 // package.json
 var package_default2 = {
   name: "@rockcarver/frodo-cli",
-  version: "4.0.0-24",
+  version: "4.0.0-26",
   type: "module",
   description: "A command line interface to manage ForgeRock Identity Cloud tenants, ForgeOps deployments, and classic deployments.",
   keywords: [