@robinmordasiewicz/f5xc-xcsh 2.0.27-2601160811 → 2.0.27-2601161624

package/dist/index.js

@@ -41228,8 +41228,8 @@ var init_logo_renderer = __esm({
 
 // src/branding/index.ts
 function getVersion() {
-  if ("v2.0.27-2601160811") {
-    return "v2.0.27-2601160811";
+  if ("v2.0.27-2601161624") {
+    return "v2.0.27-2601161624";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -50094,9 +50094,13 @@ var init_settings = __esm({
     ];
     LOGO_MODE_HELP = LOGO_MODES.map((m) => m.mode).join(", ");
     COMPLETION_MODES = [
+      {
+        mode: "standard",
+        description: "Show primary and CRUD resources with valid descriptions (default)"
+      },
       {
         mode: "all",
-        description: "Show all discovered resources (default)"
+        description: "Show all discovered resources"
       },
       {
         mode: "primary",
@@ -50108,7 +50112,7 @@ var init_settings = __esm({
     );
     DEFAULT_SETTINGS = {
       logo: "image",
-      completionMode: "all"
+      completionMode: "standard"
     };
   }
 });
@@ -77869,6 +77873,73 @@ var init_response_renderer = __esm({
   }
 });
 
+// src/repl/completion/flag-aliases.ts
+function buildFlagAliasLookup() {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const group of FLAG_ALIAS_GROUPS) {
+    const allForms = new Set(group);
+    for (const flag of group) {
+      lookup.set(flag, allForms);
+    }
+  }
+  return lookup;
+}
+var FLAG_ALIAS_GROUPS, FLAG_ALIAS_LOOKUP;
+var init_flag_aliases = __esm({
+  "src/repl/completion/flag-aliases.ts"() {
+    "use strict";
+    FLAG_ALIAS_GROUPS = [
+      ["--namespace", "-ns"],
+      ["--output", "-o"],
+      ["--name", "-n"],
+      ["--file", "-f"],
+      ["--url", "-u"],
+      ["--token", "-t"],
+      ["--limit"],
+      ["--label"],
+      ["--show-labels"],
+      ["--force"],
+      ["--cascade"]
+    ];
+    FLAG_ALIAS_LOOKUP = buildFlagAliasLookup();
+  }
+});
+
+// src/repl/completion/flag-utils.ts
+function extractUsedFlags(args) {
+  const usedFlags = /* @__PURE__ */ new Set();
+  for (const arg of args) {
+    let flagPart = arg;
+    if (arg.includes("=")) {
+      flagPart = arg.split("=")[0] ?? arg;
+    }
+    if (!flagPart.startsWith("-")) {
+      continue;
+    }
+    usedFlags.add(flagPart);
+    const aliases = FLAG_ALIAS_LOOKUP.get(flagPart);
+    if (aliases) {
+      for (const alias of aliases) {
+        usedFlags.add(alias);
+      }
+    }
+  }
+  return usedFlags;
+}
+function filterUsedFlags(suggestions, usedFlags) {
+  return suggestions.filter((s) => !usedFlags.has(s.text));
+}
+function filterUsedFlagsFromStrings(flags, args) {
+  const usedFlags = extractUsedFlags(args);
+  return flags.filter((flag) => !usedFlags.has(flag));
+}
+var init_flag_utils = __esm({
+  "src/repl/completion/flag-utils.ts"() {
+    "use strict";
+    init_flag_aliases();
+  }
+});
+
 // src/utils/usage-parser.ts
 function parseUsage(usageString) {
   if (!usageString) {
@@ -77973,25 +78044,27 @@ function stripBrackets(token) {
   return token.replace(/^[<[]/, "").replace(/[>\]]$/, "");
 }
 function generateSmartCompletions(usage, args, flags) {
+  const availableFlags = filterUsedFlagsFromStrings(flags, args);
   if (!usage) {
-    return flags;
+    return availableFlags;
   }
   const requirements = parseUsage(usage);
   const positionalArgsProvided = args.filter(
-    (arg) => !arg.startsWith("--")
+    (arg) => !arg.startsWith("-")
   ).length;
   const requiredPositional = requirements.positional.filter(
     (p) => p.required
   );
   if (positionalArgsProvided < requiredPositional.length) {
     const placeholders = requiredPositional.slice(positionalArgsProvided).map((p) => `<${p.name}>`);
-    return [...placeholders, ...flags];
+    return [...placeholders, ...availableFlags];
   }
-  return flags;
+  return availableFlags;
 }
 var init_usage_parser = __esm({
   "src/utils/usage-parser.ts"() {
     "use strict";
+    init_flag_utils();
   }
 });
 
@@ -84587,6 +84660,22 @@ var init_resource_fetcher = __esm({
 });
 
 // src/repl/completion/completer.ts
+function isResourceCompletionAppropriate(resource) {
+  if (resource.isPrimary) {
+    return true;
+  }
+  if (resource.resourceCategory && EXCLUDED_RESOURCE_CATEGORIES.has(resource.resourceCategory)) {
+    return false;
+  }
+  const desc = resource.descriptionShort || resource.description || "";
+  if (GENERIC_RESOURCE_DESCRIPTIONS.has(desc)) {
+    return false;
+  }
+  if (desc.toLowerCase() === resource.name.toLowerCase().replace(/_/g, " ")) {
+    return false;
+  }
+  return true;
+}
 function parseInputArgs(text) {
   const args = [];
   let current = "";
@@ -84671,7 +84760,7 @@ function parseInput(text) {
     currentFlag
   };
 }
-var RESOURCE_ACTIONS, Completer;
+var RESOURCE_ACTIONS, GENERIC_RESOURCE_DESCRIPTIONS, EXCLUDED_RESOURCE_CATEGORIES, Completer;
 var init_completer = __esm({
   "src/repl/completion/completer.ts"() {
     "use strict";
@@ -84683,6 +84772,7 @@ var init_completer = __esm({
     init_domains();
     init_resource_fetcher();
     init_settings();
+    init_flag_utils();
     RESOURCE_ACTIONS = /* @__PURE__ */ new Set([
       "list",
       "get",
@@ -84695,6 +84785,17 @@ var init_completer = __esm({
       "add-labels",
       "remove-labels"
     ]);
+    GENERIC_RESOURCE_DESCRIPTIONS = /* @__PURE__ */ new Set([
+      "Resource retrieval operation",
+      "Resource creation operation",
+      "Resource update operation",
+      "Resource deletion operation"
+    ]);
+    EXCLUDED_RESOURCE_CATEGORIES = /* @__PURE__ */ new Set([
+      "analytics",
+      "utility",
+      "management"
+    ]);
     Completer = class {
       session = null;
       cache;
@@ -84705,7 +84806,7 @@ var init_completer = __esm({
         this.cache = new CompletionCache();
         this.settings = loadSettingsSync();
         const cliCompletionMode = process.env.XCSH_COMPLETION_MODE;
-        if (cliCompletionMode && (cliCompletionMode === "all" || cliCompletionMode === "primary")) {
+        if (cliCompletionMode && (cliCompletionMode === "all" || cliCompletionMode === "primary" || cliCompletionMode === "standard")) {
           this.settings.completionMode = cliCompletionMode;
         }
       }
@@ -84749,9 +84850,10 @@ var init_completer = __esm({
           );
         }
         if (parsed.isCompletingFlag) {
-          return this.getFlagCompletions(
+          return this.getAvailableFlagCompletions(
             parsed.currentWord,
-            resourceCtx.action ?? void 0
+            resourceCtx.action ?? void 0,
+            parsed.args
           );
         }
         if (resourceCtx.resourceType) {
@@ -84762,29 +84864,36 @@ var init_completer = __esm({
           if (resourceNames.length > 0) {
             return resourceNames;
           }
-          return this.getActionFlagSuggestions(
+          const allFlags = this.getActionFlagSuggestions(
             resourceCtx.action ?? void 0
           );
+          const usedFlags = extractUsedFlags(parsed.args);
+          return filterUsedFlags(allFlags, usedFlags);
         }
         if (resourceCtx.domain && resourceCtx.action && RESOURCE_ACTIONS.has(resourceCtx.action) && !resourceCtx.resourceType) {
           const resourceTypes = this.getResourceTypeSuggestions(
             resourceCtx.domain
           );
           if (resourceTypes.length > 0) {
+            let suggestions2 = resourceTypes;
             if (parsed.currentWord && !parsed.currentWord.startsWith("-") && parsed.currentWord.toLowerCase() !== resourceCtx.action) {
               const filtered = this.filterSuggestions(
                 resourceTypes,
                 parsed.currentWord
               );
               if (filtered.length > 0) {
-                return filtered;
+                suggestions2 = filtered;
               }
-            } else if (!parsed.currentWord || parsed.currentWord.toLowerCase() === resourceCtx.action) {
-              return [
-                ...resourceTypes,
-                ...this.getActionFlagSuggestions(resourceCtx.action)
-              ];
             }
+            const actionFlags = this.getActionFlagSuggestions(
+              resourceCtx.action
+            );
+            const usedFlagsInContext = extractUsedFlags(parsed.args);
+            const availableActionFlags = filterUsedFlags(
+              actionFlags,
+              usedFlagsInContext
+            );
+            return [...suggestions2, ...availableActionFlags];
           }
         }
         let suggestions;
@@ -84803,9 +84912,14 @@ var init_completer = __esm({
                 if (!hasAction) {
                   suggestions = this.getActionSuggestions();
                 } else {
-                  suggestions = this.getActionFlagSuggestions(
+                  const flagsForAction = this.getActionFlagSuggestions(
                     parsed.args[1]?.toLowerCase()
                   );
+                  const usedFlagsHere = extractUsedFlags(parsed.args);
+                  suggestions = filterUsedFlags(
+                    flagsForAction,
+                    usedFlagsHere
+                  );
                 }
               } else {
                 suggestions = completionRegistry.getChildSuggestions(
@@ -85087,7 +85201,10 @@ var init_completer = __esm({
        * Get resource type suggestions for a domain
        * Phase 1 Enhancement: Uses allResources (dynamically discovered) by default
        * Falls back to primaryResources if allResources not available
-       * Respects user configuration setting for completion mode
+       * Respects user configuration setting for completion mode:
+       * - "primary": Only curated primary resources
+       * - "standard": Primary + CRUD resources with meaningful descriptions (default)
+       * - "all": Everything discovered from OpenAPI
        */
       getResourceTypeSuggestions(domain) {
         const domainInfo = getDomainInfo(domain);
@@ -85097,6 +85214,12 @@ var init_completer = __esm({
         let resources;
         if (this.settings.completionMode === "primary") {
           resources = domainInfo.primaryResources;
+        } else if (this.settings.completionMode === "standard") {
+          const allResources = domainInfo.allResources || domainInfo.primaryResources;
+          resources = allResources?.filter(isResourceCompletionAppropriate);
+          if (!resources || resources.length === 0) {
+            resources = domainInfo.primaryResources;
+          }
         } else {
           resources = domainInfo.allResources || domainInfo.primaryResources;
         }
@@ -85304,6 +85427,18 @@ var init_completer = __esm({
         const allFlags = this.getActionFlagSuggestions(action);
         return this.filterSuggestions(allFlags, prefix);
       }
+      /**
+       * Get available flag completions excluding already-used flags
+       * @param prefix - The prefix to filter by
+       * @param action - Optional action for action-specific flags
+       * @param args - Current command arguments to check for used flags
+       */
+      getAvailableFlagCompletions(prefix, action, args = []) {
+        const allFlags = this.getActionFlagSuggestions(action);
+        const usedFlags = extractUsedFlags(args);
+        const availableFlags = filterUsedFlags(allFlags, usedFlags);
+        return this.filterSuggestions(availableFlags, prefix);
+      }
       /**
        * Extract a flag value from args array
        * @param args - Array of command arguments

package/package.json

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