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

package/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.0.0-24] - 2026-03-21
+
 ## [4.0.0-23] - 2026-03-21
 
 ## [4.0.0-22] - 2026-03-20
@@ -2209,7 +2211,8 @@ 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-24...HEAD
+[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

@@ -9539,7 +9539,7 @@ var require_yesno = _chunkI43EENNMcjs.__commonJS.call(void 0, {
   "node_modules/yesno/yesno.js"(exports2, module2) {
     "use strict";
     _chunkI43EENNMcjs.init_cjs_shims.call(void 0, );
-    var readline = _chunkI43EENNMcjs.__require.call(void 0, "readline");
+    var readline2 = _chunkI43EENNMcjs.__require.call(void 0, "readline");
     var options = {
       yes: ["yes", "y"],
       no: ["no", "n"]
@@ -9556,7 +9556,7 @@ var require_yesno = _chunkI43EENNMcjs.__commonJS.call(void 0, {
         invalid = defaultInvalidHandler;
       var yValues = (yesValues || options.yes).map((v) => v.toLowerCase());
       var nValues = (noValues || options.no).map((v) => v.toLowerCase());
-      const rl = readline.createInterface({
+      const rl = readline2.createInterface({
         input: process.stdin,
         output: process.stdout
       });
@@ -238572,10 +238572,147 @@ function setup270() {
 
 // src/cli/shell/shell.ts
 _chunkI43EENNMcjs.init_cjs_shims.call(void 0, );
+var _readline = require('readline'); var _readline2 = _interopRequireDefault2(_readline);
 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, );
+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 `// ${fullPath}(${params})`;
+}
+function createFrodoCompleter(rootBindings, docsByMethod, onMethodHint) {
+  return (line) => {
+    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) => {
+    if (_optionalChain([key, 'optionalAccess', _581 => _581.sequence]) !== "(") return;
+    const currentLine = _nullishCoalesce(replServer["line"], () => ( ""));
+    const match2 = currentLine.match(
+      /([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+)$/
+    );
+    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) onHint(buildHintLine(match2[1], doc));
+  });
+}
+
 // src/ops/ShellHelpOps.ts
 _chunkI43EENNMcjs.init_cjs_shims.call(void 0, );
 var BOLD = "\x1B[1m";
@@ -238585,7 +238722,7 @@ var YELLOW = "\x1B[33m";
 var GREEN = "\x1B[32m";
 var DIM = "\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"];
@@ -238637,13 +238774,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) {
@@ -238658,31 +238819,28 @@ function createHelpContext(frodoInstance) {
       const sortedMods = [...mods].sort(alphaSort);
       console.log(`${BOLD}${CYAN}Frodo Shell - Help System${RESET}`);
       console.log("");
+      console.log(`  ${GREEN}help()${RESET}  ${DIM}this overview${RESET}`);
       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>)${RESET}  ${DIM}list all methods and modules in <module>${RESET}`
       );
       console.log(
-        `  ${GREEN}help(frodo.<sub-module>.<method name>)${RESET} -> full signature + docs for a method`
+        `  ${GREEN}help(frodo.<module>.<method>)${RESET}  ${DIM}full signature + docs for a method${RESET}`
       );
       console.log(
-        `  ${GREEN}help("methodName")${RESET}                     -> search for a method across all modules`
+        `  ${GREEN}help("methodName")${RESET}  ${DIM}search for a method across all modules${RESET}`
       );
       console.log("");
-      console.log(`${BOLD}Modules:${RESET}`);
+      const modulesCountLabel = sortedMods.length > 0 ? ` (${sortedMods.length} ${sortedMods.length === 1 ? "module" : "modules"})` : "";
+      console.log(`${BOLD}Modules${modulesCountLabel}:${RESET}`);
       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}${RESET}${countSuffix ? `  ${DIM}${countSuffix}${RESET}` : ""}`
+          );
         }
       }
       if (sortedFns.length > 0) {
@@ -238690,7 +238848,7 @@ function createHelpContext(frodoInstance) {
         console.log(`${BOLD}Factory helpers:${RESET}`);
         for (const fn of sortedFns) {
           const docs = idx.get(fn);
-          const sigHint = _optionalChain([docs, 'optionalAccess', _580 => _580.length]) ? `  ${DIM}${docs[0].signature}${RESET}` : "";
+          const sigHint = _optionalChain([docs, 'optionalAccess', _582 => _582.length]) ? `  ${DIM}${docs[0].signature}${RESET}` : "";
           console.log(`  frodo.${GREEN}${fn}${RESET}${sigHint}`);
         }
       }
@@ -238740,21 +238898,36 @@ 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}${CYAN}${moduleType}${formatCountLabel(methodCount, subModuleCount)}${RESET}`
+      );
+      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"}):${RESET}`
+          );
           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}${RESET}${countSuffix ? `  ${DIM}${countSuffix}${RESET}` : ""}`
+            );
           }
           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>)${RESET} to explore further.`
           );
         } else {
           console.log(`${YELLOW}No methods found on this object.${RESET}`);
@@ -238776,19 +238949,27 @@ function createHelpContext(frodoInstance) {
         }
       }
       if (sortedSubMods.length > 0) {
-        console.log(`${BOLD}Sub-modules:${RESET}`);
+        console.log(
+          `${BOLD}Modules (${subModuleCount} ${subModuleCount === 1 ? "module" : "modules"}):${RESET}`
+        );
         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}${RESET}${countSuffix ? `  ${DIM}${countSuffix}${RESET}` : ""}`
+          );
         }
         console.log("");
       }
       console.log(
-        `${BOLD}${CYAN}${bestType || "Module"} - ${sortedMethods.length} method(s):${RESET}`
+        `${BOLD}${CYAN}${bestType || moduleType}${formatCountLabel(methodCount, subModuleCount)}:${RESET}`
       );
       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}`);
@@ -238808,7 +238989,7 @@ function createHelpContext(frodoInstance) {
       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")${RESET}`
     );
   }
   return { help };
@@ -238896,12 +239077,33 @@ var ShellHistory = class {
 };
 
 // src/cli/shell/shell.ts
+function printHintAbovePrompt(replServer, hint) {
+  if (!replServer) return;
+  if (process.stdout.isTTY) {
+    _readline2.default.clearLine(process.stdout, 0);
+    _readline2.default.cursorTo(process.stdout, 0);
+  }
+  process.stdout.write(`
+${hint}
+`);
+  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 +239121,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", {
@@ -238973,33 +239179,33 @@ async function startRepl(allowAwait = false, host) {
       console.log("");
       console.log(`${BOLD2}Explore the Frodo API:${RESET2}`);
       console.log(
-        `  ${GREEN2}help()${RESET2}                          ${DIM2}browse all modules and methods${RESET2}`
+        `  ${GREEN2}help()${RESET2}  ${DIM2}browse all modules and methods${RESET2}`
       );
       console.log(
-        `  ${GREEN2}help(frodo.X)${RESET2}                   ${DIM2}list all methods in module X${RESET2}`
+        `  ${GREEN2}help(frodo.<module>)${RESET2}  ${DIM2}list all methods in module X${RESET2}`
       );
       console.log(
-        `  ${GREEN2}help(frodo.X.method)${RESET2}            ${DIM2}show full signature and docs${RESET2}`
+        `  ${GREEN2}help(frodo.<module>.<method>)${RESET2}  ${DIM2}show full signature and docs${RESET2}`
       );
       console.log(
-        `  ${GREEN2}help("methodName")${RESET2}              ${DIM2}search for a method across all modules${RESET2}`
+        `  ${GREEN2}help("methodName")${RESET2}  ${DIM2}search for a method across all modules${RESET2}`
       );
       console.log("");
       console.log(`${BOLD2}Sample commands:${RESET2}`);
       console.log(
-        `  ${GREEN2}frodo.info.getInfo()${RESET2}            ${DIM2}print info about the connected environment${RESET2}`
+        `  ${GREEN2}frodo.info.getInfo()${RESET2}  ${DIM2}print info about the connected environment${RESET2}`
       );
       console.log(
-        `  ${GREEN2}frodo.login.getTokens()${RESET2}         ${DIM2}get fresh or cached tokens${RESET2}`
+        `  ${GREEN2}frodo.login.getTokens()${RESET2}  ${DIM2}get fresh or cached tokens${RESET2}`
       );
       console.log(
-        `  ${GREEN2}frodo${RESET2}                           ${DIM2}show a hierarchy of all Frodo Library commands${RESET2}`
+        `  ${GREEN2}frodo${RESET2}  ${DIM2}show a hierarchy of all Frodo Library commands${RESET2}`
       );
       console.log("");
       console.log(`${BOLD2}Shell dot-commands:${RESET2}`);
       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]), () => ( ""));
+        const helpText = _nullishCoalesce(_optionalChain([commands, 'access', _589 => _589[name], 'optionalAccess', _590 => _590.help]), () => ( ""));
         console.log(`  ${GREEN2}.${name}${RESET2}  ${DIM2}${helpText}${RESET2}`);
       }
       this.displayPrompt();
@@ -239407,7 +239613,7 @@ var compareVersions = (v12, v2) => {
 // package.json
 var package_default2 = {
   name: "@rockcarver/frodo-cli",
-  version: "4.0.0-24",
+  version: "4.0.0-25",
   type: "module",
   description: "A command line interface to manage ForgeRock Identity Cloud tenants, ForgeOps deployments, and classic deployments.",
   keywords: [