thor-completion 0.0.0

data/lib/thor/completion/powershell.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+class Thor
+  module Completion
+    class Powershell
+      include SchemaValidator
+
+      attr_reader :output, :schema, :name, :commands, :global_options
+
+      def initialize(schema)
+        validate_schema!(schema)
+
+        @schema = schema
+        @name = schema[:name]
+        @commands = schema[:commands] || []
+        @global_options = schema[:globalOptions] || []
+        @output = []
+      end
+
+      def call
+        generate_completion_function
+
+        output.join("\n")
+      end
+
+      private def generate_completion_function
+        output << "using namespace System.Management.Automation"
+        output << "using namespace System.Management.Automation.Language"
+        output << ""
+        output << "Register-ArgumentCompleter -Native -CommandName #{name} -ScriptBlock {"
+        output << "    param($wordToComplete, $commandAst, $cursorPosition)"
+        output << ""
+        output << "    $commandElements = $commandAst.CommandElements"
+        output << "    $command = @("
+        output << "        '#{name}'"
+        output << "        for ($i = 1; $i -lt $commandElements.Count; $i++) {"
+        output << "            $element = $commandElements[$i]"
+        output << "            if ($element -isnot [StringConstantExpressionAst] -or"
+        output << "                $element.StringConstantType -ne [StringConstantType]::BareWord -or"
+        output << "                $element.Value.StartsWith('-') -or"
+        output << "                $element.Value -eq $wordToComplete) {"
+        output << "                break"
+        output << "            }"
+        output << "            $element.Value"
+        output << "        }"
+        output << "    ) -join ';'"
+        output << ""
+        output << "    $completions = @(switch ($command) {"
+
+        generate_command_completions("", commands, [name])
+
+        output << "    })"
+        output << ""
+        output << "    $completions.Where{ $_.CompletionText -like \"$wordToComplete*\" } |"
+        output << "        Sort-Object -Property ListItemText"
+        output << "}"
+      end
+
+      private def generate_command_completions(prefix, cmds, path)
+        path_str = path.join(";")
+
+        # Generate completions for this level
+        output << "        #{quote_ps(path_str)} {"
+
+        # Add commands/subcommands
+        cmds.reject {|c| c[:hidden] }.each do |cmd|
+          cmd_name = cmd[:name]
+          cmd_desc = escape_ps(cmd[:description] || "")
+
+          output << "            [CompletionResult]::new(#{quote_ps(cmd_name)}, #{quote_ps(cmd_name)}, [CompletionResultType]::ParameterValue, #{quote_ps(cmd_desc)})"
+        end
+
+        # Add global options if at root level
+        if path.length == 1
+          global_options.reject {|opt| opt[:hidden] }.each do |opt|
+            generate_option_completions(opt)
+          end
+        end
+
+        output << "            break"
+        output << "        }"
+
+        # Recursively generate completions for subcommands
+        cmds.each do |cmd|
+          next if cmd[:hidden]
+
+          cmd_name = cmd[:name]
+          new_path = path + [cmd_name]
+
+          # Generate completions for this command's options and arguments
+          if cmd[:options]&.any? || cmd[:arguments]&.any?
+            cmd_path_str = new_path.join(";")
+            output << "        #{quote_ps(cmd_path_str)} {"
+
+            # Add options
+            if cmd[:options]&.any?
+              cmd[:options].reject {|opt| opt[:hidden] }.each do |opt|
+                generate_option_completions(opt)
+              end
+            end
+
+            # Add arguments completion (file completion as default)
+            if cmd[:arguments]&.any?
+              arg = cmd[:arguments].first
+              if arg[:completion]
+                case arg[:completion][:type]
+                when "file"
+                  output << "            # File completion"
+                  output << "            Get-ChildItem -Path . -File | ForEach-Object {"
+                  output << "                [CompletionResult]::new($_.Name, $_.Name, [CompletionResultType]::ParameterValue, $_.Name)"
+                  output << "            }"
+                when "directory"
+                  output << "            # Directory completion"
+                  output << "            Get-ChildItem -Path . -Directory | ForEach-Object {"
+                  output << "                [CompletionResult]::new($_.Name, $_.Name, [CompletionResultType]::ParameterValue, $_.Name)"
+                  output << "            }"
+                end
+              end
+            end
+
+            output << "            break"
+            output << "        }"
+          end
+
+          # Recurse for subcommands
+          generate_command_completions("#{prefix}#{cmd_name};", cmd[:subcommands], new_path) if cmd[:subcommands]&.any?
+        end
+      end
+
+      private def generate_option_completions(opt)
+        opt_desc = escape_ps(opt[:description] || "")
+
+        # Add short option if available
+        if opt[:short]
+          Array(opt[:short]).each do |short|
+            short_flag = "-#{short}"
+            output << "            [CompletionResult]::new(#{quote_ps(short_flag)}, #{quote_ps(short_flag)}, [CompletionResultType]::ParameterName, #{quote_ps(opt_desc)})"
+          end
+        end
+
+        # Add long option
+        return unless opt[:name]
+
+        long_flag = "--#{opt[:name]}"
+        output << "            [CompletionResult]::new(#{quote_ps(long_flag)}, #{quote_ps(long_flag)}, [CompletionResultType]::ParameterName, #{quote_ps(opt_desc)})"
+
+        # For options with enum values, we could add value completions
+        # but that would require tracking the previous word, which is complex in PowerShell
+      end
+
+      private def quote_ps(str)
+        "'#{str.to_s.gsub("'", "''")}'"
+      end
+
+      private def escape_ps(str)
+        str.to_s.gsub("'", "''")
+      end
+
+      private def sanitize_name(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      end
+    end
+  end
+end

data/lib/thor/completion/schema.json

@@ -0,0 +1,208 @@
+{
+  "title": "Shell Completion Schema",
+  "description": "A universal schema for defining shell completions that can be converted to bash, zsh, fish, etc.",
+  "type": "object",
+  "required": ["name", "commands"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the CLI program"
+    },
+    "description": {
+      "type": "string",
+      "description": "A brief description of the CLI program"
+    },
+    "version": {
+      "type": "string",
+      "description": "The version of the CLI program"
+    },
+    "commands": {
+      "type": "array",
+      "description": "List of available commands",
+      "items": {
+        "$ref": "#/definitions/command"
+      }
+    },
+    "globalOptions": {
+      "type": "array",
+      "description": "Options available to all commands",
+      "items": {
+        "$ref": "#/definitions/option"
+      }
+    }
+  },
+  "definitions": {
+    "command": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The command name"
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of what the command does"
+        },
+        "aliases": {
+          "type": "array",
+          "description": "Alternative names for this command",
+          "items": {
+            "type": "string"
+          }
+        },
+        "options": {
+          "type": "array",
+          "description": "Command-specific options",
+          "items": {
+            "$ref": "#/definitions/option"
+          }
+        },
+        "arguments": {
+          "type": "array",
+          "description": "Positional arguments for the command",
+          "items": {
+            "$ref": "#/definitions/argument"
+          }
+        },
+        "subcommands": {
+          "type": "array",
+          "description": "Nested subcommands",
+          "items": {
+            "$ref": "#/definitions/command"
+          }
+        },
+        "hidden": {
+          "type": "boolean",
+          "description": "Whether this command should be hidden from completions",
+          "default": false
+        }
+      }
+    },
+    "option": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The long option name (without --)"
+        },
+        "short": {
+          "oneOf": [
+            {
+              "type": "string",
+              "description": "The short option flag (single character)",
+              "pattern": "^[a-zA-Z0-9]+$"
+            },
+            {
+              "type": "array",
+              "description": "Multiple short option flags",
+              "items": {
+                "type": "string",
+                "pattern": "^[a-zA-Z0-9]+$"
+              }
+            }
+          ]
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the option"
+        },
+        "type": {
+          "type": "string",
+          "enum": ["boolean", "string", "integer", "float", "array", "hash"],
+          "description": "The type of value this option accepts",
+          "default": "boolean"
+        },
+        "required": {
+          "type": "boolean",
+          "description": "Whether this option is required",
+          "default": false
+        },
+        "default": {
+          "description": "The default value for this option"
+        },
+        "enum": {
+          "type": "array",
+          "description": "Valid values for this option",
+          "items": {
+            "type": "string"
+          }
+        },
+        "completion": {
+          "$ref": "#/definitions/completion"
+        },
+        "repeatable": {
+          "type": "boolean",
+          "description": "Whether this option can be specified multiple times",
+          "default": false
+        },
+        "hidden": {
+          "type": "boolean",
+          "description": "Whether this option should be hidden from completions",
+          "default": false
+        }
+      }
+    },
+    "argument": {
+      "type": "object",
+      "required": ["name"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "description": "The argument name"
+        },
+        "description": {
+          "type": "string",
+          "description": "A brief description of the argument"
+        },
+        "required": {
+          "type": "boolean",
+          "description": "Whether this argument is required",
+          "default": true
+        },
+        "variadic": {
+          "type": "boolean",
+          "description": "Whether this argument accepts multiple values",
+          "default": false
+        },
+        "completion": {
+          "$ref": "#/definitions/completion"
+        }
+      }
+    },
+    "completion": {
+      "type": "object",
+      "description": "Defines how to complete values for this option or argument",
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["static", "dynamic", "file", "directory", "command"],
+          "description": "The type of completion to perform"
+        },
+        "values": {
+          "type": "array",
+          "description": "Static list of completion values (for type: static)",
+          "items": {
+            "type": "string"
+          }
+        },
+        "command": {
+          "type": "string",
+          "description": "Shell command to generate completions (for type: dynamic)"
+        },
+        "pattern": {
+          "type": "string",
+          "description": "File glob pattern (for type: file)"
+        },
+        "extensions": {
+          "type": "array",
+          "description": "File extensions to complete (for type: file)",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

data/lib/thor/completion/schema_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Thor
+  module Completion
+    module SchemaValidator
+      def validate_schema!(schema)
+        schema_path = File.join(__dir__, "schema.json")
+        errors = JSON::Validator.fully_validate("file://#{schema_path}", schema)
+
+        return if errors.empty?
+
+        raise ArgumentError, "Invalid attributes: #{errors.first}"
+      end
+    end
+  end
+end

data/lib/thor/completion/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Thor
+  module Completion
+    VERSION = "0.0.0"
+  end
+end