@robinmordasiewicz/f5xc-xcsh 2.0.13-2601051841 → 2.0.13-2601052351

package/dist/index.js

@@ -46994,8 +46994,8 @@ function getLogoModeFromEnv(envPrefix) {
 var CLI_NAME = "xcsh";
 var CLI_FULL_NAME = "F5 Distributed Cloud Shell";
 function getVersion() {
-  if ("v2.0.13-2601051841") {
-    return "v2.0.13-2601051841";
+  if ("v2.0.13-2601052351") {
+    return "v2.0.13-2601052351";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -47920,6 +47920,9 @@ function getValue(row, accessor) {
     if (accessor === "labels") {
       return formatLabelsValue(value);
     }
+    if (isComplexValue(value)) {
+      return formatIndentedTree(value, 0, 4, 40).join("\n");
+    }
     return JSON.stringify(value);
   }
   return String(value);
@@ -47931,6 +47934,135 @@ function formatLabelsValue(labels) {
   }
   return `map[${entries.join(" ")}]`;
 }
+function isComplexValue(value) {
+  if (value === null || value === void 0) return false;
+  if (typeof value !== "object") return false;
+  if (Array.isArray(value)) {
+    return value.some((item) => typeof item === "object" && item !== null);
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  if (keys.length > 3) return true;
+  return keys.some((k) => {
+    const v = obj[k];
+    return typeof v === "object" && v !== null;
+  });
+}
+function formatIndentedTree(value, indent = 0, maxDepth = 6, maxWidth = 60) {
+  const INDENT_SIZE = 2;
+  const lines = [];
+  if (value === null) {
+    return ["null"];
+  }
+  if (value === void 0) {
+    return [""];
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (indent / INDENT_SIZE >= maxDepth) {
+    const json = JSON.stringify(value);
+    return json.length > maxWidth ? [json.slice(0, maxWidth - 3) + "..."] : [json];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return ["[]"];
+    }
+    const isSimple = value.every(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v === null
+    );
+    if (isSimple && value.length <= 5) {
+      const inline = `[${value.map((v) => v === null ? "null" : String(v)).join(", ")}]`;
+      if (inline.length <= maxWidth) {
+        return [inline];
+      }
+    }
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const prefix = `[${i}]: `;
+      if (typeof item === "object" && item !== null) {
+        lines.push(prefix);
+        const subLines = formatIndentedTree(
+          item,
+          indent + INDENT_SIZE,
+          maxDepth,
+          maxWidth
+        );
+        for (const subLine of subLines) {
+          lines.push(" ".repeat(INDENT_SIZE) + subLine);
+        }
+      } else {
+        const formatted = formatIndentedTree(
+          item,
+          indent,
+          maxDepth,
+          maxWidth
+        );
+        lines.push(prefix + formatted[0]);
+      }
+    }
+    return lines;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return ["{}"];
+    }
+    if (keys.length <= 2) {
+      const allSimple = keys.every((k) => {
+        const v = obj[k];
+        return v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "object" && v !== null && Object.keys(v).length === 0;
+      });
+      if (allSimple) {
+        const inline = keys.map((k) => {
+          const v = obj[k];
+          if (v === null) return `${k}: null`;
+          if (typeof v === "object" && Object.keys(v).length === 0) {
+            return Array.isArray(v) ? `${k}: []` : `${k}: {}`;
+          }
+          return `${k}: ${v}`;
+        }).join(", ");
+        if (inline.length <= maxWidth) {
+          return [inline];
+        }
+      }
+    }
+    for (const key of keys) {
+      const childValue = obj[key];
+      if (typeof childValue === "object" && childValue !== null) {
+        const childObj = childValue;
+        const isEmpty = Array.isArray(childObj) ? childObj.length === 0 : Object.keys(childObj).length === 0;
+        if (isEmpty) {
+          lines.push(
+            `${key}: ${Array.isArray(childObj) ? "[]" : "{}"}`
+          );
+        } else {
+          lines.push(`${key}:`);
+          const subLines = formatIndentedTree(
+            childValue,
+            indent + INDENT_SIZE,
+            maxDepth,
+            maxWidth
+          );
+          for (const subLine of subLines) {
+            lines.push(" ".repeat(INDENT_SIZE) + subLine);
+          }
+        }
+      } else {
+        const formatted = formatIndentedTree(
+          childValue,
+          indent,
+          maxDepth,
+          maxWidth
+        );
+        lines.push(`${key}: ${formatted[0]}`);
+      }
+    }
+    return lines;
+  }
+  return [String(value)];
+}
 function calculateColumnWidths(columns, rows, maxTableWidth) {
   const widths = columns.map((col) => {
     let width = col.header.length;
@@ -48117,11 +48249,19 @@ function formatKeyValueBox(data, title, noColor = false, maxWidth) {
   const contentLines = [];
   for (const d of data) {
     const paddedLabel = d.label.padEnd(maxLabelWidth);
-    const wrappedValueLines = wrapText2(d.value, maxValueWidth);
-    contentLines.push(`${paddedLabel}:  ${wrappedValueLines[0] ?? ""}`);
     const indent = " ".repeat(maxLabelWidth + 3);
-    for (let i = 1; i < wrappedValueLines.length; i++) {
-      contentLines.push(`${indent}${wrappedValueLines[i]}`);
+    const valueLines = d.value.split("\n");
+    let isFirstLine = true;
+    for (const valueLine of valueLines) {
+      const wrappedLines = wrapText2(valueLine, maxValueWidth);
+      for (const wrappedLine of wrappedLines) {
+        if (isFirstLine) {
+          contentLines.push(`${paddedLabel}:  ${wrappedLine}`);
+          isFirstLine = false;
+        } else {
+          contentLines.push(`${indent}${wrappedLine}`);
+        }
+      }
     }
   }
   const titleText = ` ${title} `;
@@ -48181,7 +48321,7 @@ function formatDetailValue(value) {
     if (isSimple && value.length <= 5) {
       return `[${value.join(", ")}]`;
     }
-    return JSON.stringify(value);
+    return formatIndentedTree(value, 0, 6, 60).join("\n");
   }
   if (typeof value === "object") {
     const obj = value;
@@ -48195,7 +48335,7 @@ function formatDetailValue(value) {
         return keys.map((k) => `${k}: ${obj[k]}`).join(", ");
       }
     }
-    return JSON.stringify(value);
+    return formatIndentedTree(value, 0, 6, 60).join("\n");
   }
   return String(value);
 }
@@ -151712,7 +151852,8 @@ var Completer = class {
     if (parsed.isCompletingFlagValue && parsed.currentFlag) {
       return await this.getFlagValueCompletions(
         parsed.currentFlag,
-        parsed.currentWord
+        parsed.currentWord,
+        parsed
       );
     }
     if (parsed.isCompletingFlag) {
@@ -152211,10 +152352,24 @@ var Completer = class {
     const allFlags = this.getActionFlagSuggestions(action);
     return this.filterSuggestions(allFlags, prefix);
   }
+  /**
+   * Extract a flag value from args array
+   * @param args - Array of command arguments
+   * @param flagNames - Flag names to look for (e.g., ["--namespace", "-ns"])
+   * @returns The flag value or undefined if not found
+   */
+  extractFlagValue(args, flagNames) {
+    for (let i = 0; i < args.length - 1; i++) {
+      if (flagNames.includes(args[i] ?? "")) {
+        return args[i + 1];
+      }
+    }
+    return void 0;
+  }
   /**
    * Get flag value completions based on the flag being completed
    */
-  async getFlagValueCompletions(flag, partial) {
+  async getFlagValueCompletions(flag, partial, parsed) {
     let valuePartial = partial;
     if (partial.includes("=")) {
       valuePartial = partial.slice(partial.indexOf("=") + 1);
@@ -152234,18 +152389,28 @@ var Completer = class {
       case "-ns":
         return this.completeNamespace(valuePartial);
       case "--name":
-      case "-n":
-        if (this.session) {
-          const ctx = this.session.getContextPath();
-          if (ctx.domain) {
-            return this.completeResourceName(
-              ctx.domain,
-              ctx.domain,
-              valuePartial
-            );
-          }
+      case "-n": {
+        if (!this.session) {
+          return [];
+        }
+        const resourceCtx = this.parseResourceContext(parsed);
+        const navCtx = this.session.getContextPath();
+        const resourceType = resourceCtx.resourceType || navCtx.domain || null;
+        const nsFromFlag = this.extractFlagValue(parsed.args, [
+          "--namespace",
+          "-ns"
+        ]);
+        const namespace = nsFromFlag || this.session.getNamespace();
+        if (resourceType && namespace) {
+          return this.completeResourceName(
+            resourceType,
+            resourceType,
+            valuePartial,
+            namespace
+          );
         }
         return [];
+      }
       case "--limit":
         return [
           {
@@ -152306,8 +152471,8 @@ var Completer = class {
   /**
    * Complete resource names with caching
    */
-  async completeResourceName(domain, _resourceType, partial) {
-    const namespace = this.session?.getNamespace() ?? "default";
+  async completeResourceName(domain, _resourceType, partial, namespaceOverride) {
+    const namespace = namespaceOverride || this.session?.getNamespace() || "default";
     const cacheKey = `${domain}:${namespace}`;
     const names = await this.cache.getResourceNames(cacheKey, async () => {
       const client = this.session?.getAPIClient();
@@ -152503,6 +152668,8 @@ var BUILTIN_COMMANDS = /* @__PURE__ */ new Set([
   "ctx",
   "history",
   "version",
+  "--version",
+  "-v",
   "domains",
   "whoami",
   "refresh"
@@ -152543,7 +152710,12 @@ function parseCommand(input) {
   const firstWord = trimmed.split(/\s+/)[0]?.toLowerCase() ?? "";
   const normalizedFirst = firstWord.startsWith("/") ? firstWord.slice(1) : firstWord;
   if (BUILTIN_COMMANDS.has(firstWord) || BUILTIN_COMMANDS.has(normalizedFirst)) {
-    const effectiveCommand = normalizedFirst === "--help" || normalizedFirst === "-h" ? "help" : normalizedFirst;
+    let effectiveCommand = normalizedFirst;
+    if (normalizedFirst === "--help" || normalizedFirst === "-h") {
+      effectiveCommand = "help";
+    } else if (normalizedFirst === "--version" || normalizedFirst === "-v") {
+      effectiveCommand = "version";
+    }
     return {
       raw: effectiveCommand,
       isDirectNavigation: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinmordasiewicz/f5xc-xcsh",
-  "version": "2.0.13-2601051841",
+  "version": "2.0.13-2601052351",
   "description": "F5 Distributed Cloud Shell - Interactive CLI for F5 XC",
   "type": "module",
   "bin": {