wisco 0.3.6 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc712af30ea2647f51bf72fac2bcf59f57105efcd8382d831afcadceee912f5c
-  data.tar.gz: b49f08a071f353521d09469452e8508e31b78f4108545b6e723083e816ecc67d
+  metadata.gz: a6489b0aaac5c9626f27141afebc7b4dda9b087c2cf94fee0744b9b603de4953
+  data.tar.gz: 298e1469cd688e9d824fd091d32ea84526934637b96e92a4ea19243dfb715e49
 SHA512:
-  metadata.gz: 4029281c6717dc8eeef9b9b3d86018998c5846dea82d5703d10229b84bf990c8beb6d8c73928315804878b8c9ab6a5bc541b9e46b34ddef7d601c2590e354331
-  data.tar.gz: 7a4161111ce339ffe212cacdd08365f9464b79d02a729b492e04925ed2d2a9f10687fdcd79d0eef0fcadc321cf37c9a5fb05eca57f63f3d7da747b3438204e14
+  metadata.gz: 4b711094e3bf5990c6a591a9a75356660c86d813a76df331f101c8cf48ecbf3d98edcf9f4ede28c4c3cff1448f19991ef89383a1fecb5c78c8a21a3b1a1ce88c
+  data.tar.gz: 1581e25abeb992cb6eee659407561df32a47ecbe2cacacf9bb5ea55650eabe27015114c97cf6d5f5bcbba4acbf5593416c1bb5b37ca612f682b7095ba3708ccb

data/lib/wisco/commands/exec.rb

@@ -1,16 +1,18 @@
 require 'fileutils'
+require 'tempfile'
 require 'workato/connector/sdk'
 require 'workato/cli/exec_command'
 require_relative '../config'
 require_relative '../connector'
 require_relative '../path_utils'
+require_relative '../exec_script'
 
 module Wisco
   module Commands
     module Exec
       module_function
 
-      def run(path_arg, target_dir, input: nil, pagination: true, verbose: true, debug: false,
+      def run(path_arg, target_dir, input: nil, pagination: true, verbose: false, debug: false,
               extended: true, closure: nil, config_fields: nil, continue: nil,
               extended_input_schema: nil, extended_output_schema: nil)
         target_dir = File.expand_path(target_dir)
@@ -54,7 +56,7 @@ module Wisco
             next
           end
 
-          input_files = resolve_input_files(input, fixtures_dir)
+          input_files = resolve_input_files(input, fixtures_dir, debug: debug)
 
           if input_files.empty?
             if %w[pick_lists methods].include?(section)
@@ -71,19 +73,32 @@ module Wisco
           end
 
           input_files.each do |input_file|
-            execute_one(section, key, input_file, fixtures_dir,
-                        connector_full_path, connection, pagination: pagination, verbose: verbose,
-                        extended: extended, closure: closure, config_fields: config_fields,
-                        continue: continue, extended_input_schema: extended_input_schema,
-                        extended_output_schema: extended_output_schema, debug: debug)
+            if File.extname(input_file).downcase == '.rb'
+              execute_ruby_script(section, key, input_file, fixtures_dir, target_dir,
+                                  connector_full_path, connection, config,
+                                  pagination: pagination, verbose: verbose,
+                                  extended: extended, closure: closure, config_fields: config_fields,
+                                  continue: continue, extended_input_schema: extended_input_schema,
+                                  extended_output_schema: extended_output_schema, debug: debug)
+            else
+              execute_one(section, key, input_file, fixtures_dir,
+                          connector_full_path, connection, pagination: pagination, verbose: verbose,
+                          extended: extended, closure: closure, config_fields: config_fields,
+                          continue: continue, extended_input_schema: extended_input_schema,
+                          extended_output_schema: extended_output_schema, debug: debug)
+            end
           end
         end
       end
 
       # Resolve the list of input files to execute.
       # If an explicit input filename/path is given, use that (relative to fixtures_dir).
-      # Otherwise glob execute_* in fixtures_dir and exclude files still containing the sentinel.
-      def resolve_input_files(input, fixtures_dir)
+      # Otherwise glob execute_*.{json,rb} in fixtures_dir and exclude files still containing
+      # their respective sentinel.
+      #
+      # In debug mode, prints which candidate files were found and which were
+      # skipped (because they still contain a sentinel comment).
+      def resolve_input_files(input, fixtures_dir, debug: false)
         if input
           path = File.absolute_path?(input) ? input : File.join(fixtures_dir, input)
           unless File.exist?(path)
@@ -92,13 +107,28 @@ module Wisco
           end
           [path]
         else
-          Dir.glob(File.join(fixtures_dir, 'execute_*')).select do |f|
-            File.file?(f) && !file_has_sentinel?(f)
+          candidates = Dir.glob(File.join(fixtures_dir, 'execute_*.{json,rb}')).select { |f| File.file?(f) }
+          warn "[exec] candidate files: #{candidates.map { |f| File.basename(f) }}" if debug
+          candidates.reject do |f|
+            if file_has_sentinel?(f)
+              warn "[exec]   skipped (sentinel): #{File.basename(f)}" if debug
+              true
+            else
+              false
+            end
           end
         end
       end
 
+      # Returns true if the file should be skipped. Each input format has its own
+      # sentinel convention:
+      #   .json — first line exactly equals Wisco::Commands::Fixtures::SENTINEL
+      #   .rb   — first non-blank line matches `# WISCO_SKIP`
       def file_has_sentinel?(path)
+        if File.extname(path).downcase == '.rb'
+          return Wisco::ExecScript.sentinel?(path)
+        end
+
         first_line = begin
           File.open(path, &:readline).chomp
         rescue StandardError
@@ -114,7 +144,7 @@ module Wisco
         File.dirname(value) == '.' ? File.join(fixtures_dir, value) : value
       end
 
-      def run_test(target_dir, connector_full_path, connection, verbose: true, debug: false)
+      def run_test(target_dir, connector_full_path, connection, verbose: false, debug: false)
         puts "Testing connection"
         fixtures_dir = File.join(target_dir, 'fixtures', 'connection', 'test')
         FileUtils.mkdir_p(fixtures_dir)
@@ -152,7 +182,7 @@ module Wisco
       end
 
       def execute_one(section, key, input_file, fixtures_dir, connector_full_path, connection,
-                      pagination: true, verbose: true, debug: false,
+                      pagination: true, verbose: false, debug: false,
                       extended: true, closure: nil, config_fields: nil, continue: nil,
                       extended_input_schema: nil, extended_output_schema: nil)
         stem        = input_file ? File.basename(input_file, '.*') : 'execute'
@@ -172,7 +202,11 @@ module Wisco
         options[:connection] = connection if connection
         options[:verbose]    = verbose
         if use_args
-          options[:args] = input_file if input_file
+          if input_file && section == 'methods'
+            options[:args] = normalize_method_args(input_file)
+          elsif input_file
+            options[:args] = input_file
+          end
         else
           options[:input] = input_file
         end
@@ -223,6 +257,7 @@ module Wisco
           cmd = Workato::CLI::ExecCommand.new(path: exec_path, options: options)
           cmd.call
         rescue StandardError => e
+          FileUtils.rm_f(output_file)
           File.write(error_file, "#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}\n")
           Wisco::TerminalOutput.emit_error("Error executing #{section}.#{key} with #{input_file ? File.basename(input_file) : 'no input'}: #{e.message}")
           Wisco::TerminalOutput.emit_error("  Details written to: #{error_file}")
@@ -237,6 +272,148 @@ module Wisco
         File.write(output_file, pretty + "\n")
         puts "  Written: #{output_file}"
       end
+
+      # Handles `execute_*.rb` scripts: evaluates the script to produce dynamic
+      # input, writes it to <subdir>/input.json, runs the connector item via
+      # ExecCommand, and writes <subdir>/output.json or <subdir>/error.txt.
+      # The subdirectory is named after the script (without .rb), e.g.
+      # execute_input.rb -> execute_input/.
+      def execute_ruby_script(section, key, script_path, fixtures_dir, target_dir,
+                              connector_full_path, connection, config,
+                              pagination: true, verbose: false, debug: false,
+                              extended: true, closure: nil, config_fields: nil, continue: nil,
+                              extended_input_schema: nil, extended_output_schema: nil)
+        subdir      = File.join(fixtures_dir, File.basename(script_path, '.rb'))
+        FileUtils.mkdir_p(subdir)
+        input_file  = File.join(subdir, 'input.json')
+        output_file = File.join(subdir, 'output.json')
+        error_file  = File.join(subdir, 'error.txt')
+
+        # Step 1: evaluate the script to obtain dynamic input
+        connection_name = config['connection'] || 'default'
+
+        begin
+          generated = Wisco::ExecScript.evaluate(
+            script_path:         script_path,
+            connector_full_path: connector_full_path,
+            target_dir:          target_dir,
+            connection_name:     connection_name
+          )
+        rescue StandardError => e
+          FileUtils.rm_f(input_file)
+          FileUtils.rm_f(output_file)
+          File.write(error_file, "#{e.class}: #{e.message}\n\n#{Array(e.backtrace).join("\n")}\n")
+          Wisco::TerminalOutput.emit_error("Error evaluating #{File.basename(script_path)}: #{e.message}")
+          Wisco::TerminalOutput.emit_error("  Details written to: #{error_file}")
+          return
+        end
+
+        File.write(input_file, JSON.pretty_generate(generated) + "\n")
+        puts "  Generated: #{input_file}"
+
+        # Step 2: build ExecCommand options (mirrors execute_one)
+        use_args  = %w[pick_lists methods].include?(section)
+        exec_path = if use_args
+                      "#{section}.#{key}"
+                    elsif section == 'triggers'
+                      pagination ? "#{section}.#{key}.poll" : "#{section}.#{key}.poll_page"
+                    else
+                      "#{section}.#{key}.execute"
+                    end
+
+        options = { connector: connector_full_path, output: output_file }
+        options[:connection] = connection if connection
+        options[:verbose]    = verbose
+        if use_args
+          options[:args] = section == 'methods' ? normalize_ruby_method_args(input_file) : input_file
+        else
+          options[:input] = input_file
+        end
+
+        options[:closure]       = resolve_option_path(closure,       fixtures_dir) if closure
+        options[:config_fields] = resolve_option_path(config_fields, fixtures_dir) if config_fields
+        options[:continue]      = resolve_option_path(continue,      fixtures_dir) if continue
+
+        # extended schema files still live at the item's fixtures_dir (not the subdir)
+        unless use_args
+          eis = if extended_input_schema
+                  resolve_option_path(extended_input_schema, fixtures_dir)
+                elsif extended
+                  f = File.join(fixtures_dir, 'input_fields.json')
+                  File.exist?(f) ? f : nil
+                end
+          options[:extended_input_schema] = eis if eis
+
+          eos = if extended_output_schema
+                  resolve_option_path(extended_output_schema, fixtures_dir)
+                elsif extended
+                  f = File.join(fixtures_dir, 'output_fields.json')
+                  File.exist?(f) ? f : nil
+                end
+          options[:extended_output_schema] = eos if eos
+        end
+
+        if debug
+          warn "[exec.rb] script:      #{script_path}"
+          warn "[exec.rb] subdir:      #{subdir}"
+          warn "[exec.rb] path:        #{exec_path}"
+          warn "[exec.rb] connector:   #{connector_full_path}"
+          warn "[exec.rb] connection:  #{connection.inspect}"
+          warn "[exec.rb] #{use_args ? 'args' : 'input'}:       #{input_file}"
+          warn "[exec.rb] output:      #{output_file}"
+        end
+
+        # Step 3: invoke ExecCommand against the generated input
+        begin
+          cmd = Workato::CLI::ExecCommand.new(path: exec_path, options: options)
+          cmd.call
+        rescue StandardError => e
+          FileUtils.rm_f(input_file)
+          FileUtils.rm_f(output_file)
+          File.write(error_file, "#{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}\n")
+          Wisco::TerminalOutput.emit_error("Error executing #{section}.#{key} with #{File.basename(script_path)}: #{e.message}")
+          Wisco::TerminalOutput.emit_error("  Details written to: #{error_file}")
+          return
+        end
+
+        FileUtils.rm_f(error_file)
+
+        return unless File.exist?(output_file)
+
+        pretty = JSON.pretty_generate(JSON.parse(File.read(output_file)))
+        File.write(output_file, pretty + "\n")
+        puts "  Written: #{output_file}"
+      end
+
+      # The Workato SDK's InvokePath#invoke_method applies Array.wrap(args.last).flatten(1)
+      # when the last parameter is *args, which incorrectly unwraps array-valued positional
+      # arguments one level too many. These helpers compensate by pre-wrapping Array elements
+      # so that flatten(1) cancels out and the method receives the correct value.
+
+      # For JSON execute_input files (positional-args array format):
+      # [[{h1},{h2}]] → [[[{h1},{h2}]]] so SDK flatten(1) restores [[{h1},{h2}]] → method([{h1},{h2}])
+      def normalize_method_args(input_file)
+        parsed = JSON.parse(File.read(input_file))
+        return input_file unless parsed.is_a?(Array) && parsed.any? { |a| a.is_a?(Array) }
+
+        fixed = parsed.map { |a| a.is_a?(Array) ? [a] : a }
+        tmp = Tempfile.new(['wisco_args_', '.json'])
+        tmp.write(JSON.generate(fixed))
+        tmp.close
+        tmp.path
+      end
+
+      # For Ruby-script-generated input files (direct argument value):
+      # [{h1},{h2}] → [[{h1},{h2}]] so SDK flatten(1) restores [{h1},{h2}] → method([{h1},{h2}])
+      def normalize_ruby_method_args(input_file)
+        parsed = JSON.parse(File.read(input_file))
+        return input_file unless parsed.is_a?(Array)
+
+        tmp = Tempfile.new(['wisco_args_', '.json'])
+        tmp.write(JSON.generate([parsed]))
+        tmp.close
+        tmp.path
+      end
     end
   end
 end

data/lib/wisco/commands/fixtures.rb

@@ -8,11 +8,34 @@ require_relative '../path_utils'
 module Wisco
   module Commands
     module Fixtures
-      SENTINEL = '# Remove this comment before updating. Files that include this line will be overwritten.'
+      SENTINEL    = '# Remove this comment before updating. Files that include this line will be overwritten.'
+      RB_SENTINEL = '# WISCO_SKIP'
+
+      RB_TEMPLATE = <<~RUBY
+        # WISCO_SKIP
+        # Remove the WISCO_SKIP line above once this script is ready to run.
+        #
+        # The last expression in this file becomes the input passed to the connector item.
+        # Helper methods available inside the script:
+        #   call_method(:name, *args)     — invoke a methods: entry on the connector
+        #   call_pick_list(:name, *args)  — invoke a pick_lists: entry on the connector
+        #   connection                     — Hash of decrypted settings.yaml(.enc)
+        #
+        # Example:
+        #   require 'securerandom'
+        #   {
+        #     order_number: "ORD-\#{SecureRandom.hex(4).upcase}",
+        #     created_at:   Time.now.iso8601
+        #   }
+
+        {
+          # TODO: fill in fields
+        }
+      RUBY
 
       module_function
 
-      def run(path_arg, target_dir, overwrite: false, debug: false)
+      def run(path_arg, target_dir, overwrite: false, ruby: false, debug: false)
         target_dir = File.expand_path(target_dir)
         config_path = Wisco.config_path(target_dir)
 
@@ -44,8 +67,10 @@ module Wisco
 
           if section == 'pick_lists'
             process_pick_list(key, connector, fixtures_dir, overwrite: overwrite)
+            generate_execute_input_rb(fixtures_dir, overwrite: overwrite) if ruby
           elsif section == 'methods'
             process_method(key, connector, fixtures_dir, overwrite: overwrite)
+            generate_execute_input_rb(fixtures_dir, overwrite: overwrite) if ruby
           else
             # ── config_fields pre-check ──────────────────────────────────────
             item   = connector[section.to_sym]&.[](key.to_sym)
@@ -76,6 +101,7 @@ module Wisco
             )
 
             generate_execute_input(input_fields_file, fixtures_dir, overwrite: overwrite, debug: debug)
+            generate_execute_input_rb(fixtures_dir, overwrite: overwrite) if ruby
 
             # ── output_fields ────────────────────────────────────────────────
             output_fields_file = File.join(fixtures_dir, 'output_fields.json')
@@ -133,6 +159,35 @@ module Wisco
         puts "  Written: #{output_file}"
       end
 
+      # Writes an `execute_input.rb` template into `fixtures_dir`. The template
+      # is prefixed with `# WISCO_SKIP` so it is identifiable as unedited and
+      # will be skipped by `wisco exec` until the user removes that line.
+      #
+      # Overwrite rules mirror generate_execute_input:
+      #   - File absent                       -> write
+      #   - File present, # WISCO_SKIP on L1  -> overwrite (still a template)
+      #   - File present, no sentinel         -> skip (user-edited); force with --overwrite
+      def generate_execute_input_rb(fixtures_dir, overwrite: false)
+        output_file = File.join(fixtures_dir, 'execute_input.rb')
+
+        if File.exist?(output_file)
+          first_line = begin
+            File.open(output_file, &:readline).chomp
+          rescue StandardError
+            ''
+          end
+          has_sentinel = first_line.strip == RB_SENTINEL
+
+          unless has_sentinel || overwrite
+            puts "  Skipped (user-edited): #{output_file}"
+            return
+          end
+        end
+
+        File.write(output_file, RB_TEMPLATE)
+        puts "  Written: #{output_file}"
+      end
+
       # Recursively converts a Workato schema array into a template hash.
       # Scalars become "<type_value_required|optional>" placeholder strings.
       # Objects expand into a nested hash via their properties.

data/lib/wisco/exec_script.rb

@@ -0,0 +1,160 @@
+require 'workato/connector/sdk'
+require_relative 'terminal_output'
+
+module Wisco
+  # Evaluates an `execute_*.rb` script and returns the value of its last
+  # expression. The script is eval'd inside a binding that exposes helpers
+  # (`call_method`, `call_pick_list`, `connection`) so the script can build
+  # dynamic input that varies per run.
+  module ExecScript
+    SENTINEL_REGEX = /\A\s*#\s*WISCO_SKIP\b/.freeze
+
+    module_function
+
+    # Returns true if the file's first non-blank line is a `# WISCO_SKIP`
+    # comment, in which case the script should be skipped by `wisco exec`.
+    def sentinel?(path)
+      File.foreach(path) do |line|
+        stripped = line.strip
+        next if stripped.empty?
+        return SENTINEL_REGEX.match?(line)
+      end
+      false
+    rescue StandardError
+      false
+    end
+
+    # Evaluates the script at `script_path` and returns the value of its last
+    # expression. Raises StandardError subclasses on:
+    #   - syntax / runtime errors in the script
+    #   - invalid return value (must be a Hash or Array)
+    #
+    # `connector_full_path` — absolute path to connector.rb (used to build
+    #                          the SDK Connector for helper invocations).
+    # `target_dir`          — connector project root (used to find
+    #                          settings.yaml(.enc) + master.key).
+    # `connection_name`     — connection key inside settings.yaml; defaults to 'default'.
+    def evaluate(script_path:, connector_full_path:, target_dir:, connection_name: 'default')
+      host   = ScriptHost.new(connector_full_path, target_dir, connection_name)
+      source = File.read(script_path)
+      result = host.instance_eval(source, script_path, 1)
+
+      unless result.is_a?(Hash) || result.is_a?(Array)
+        raise InvalidReturn,
+              "Script must return a Hash (for actions/triggers) or Array/Hash (for methods/pick_lists). " \
+              "Got: #{result.class}"
+      end
+
+      result
+    end
+
+    class InvalidReturn < StandardError; end
+
+    # Host object that the script is eval'd against. Exposes the helper API.
+    # Defined as a class (not a Module) so `instance_eval` gives the script
+    # access to standard top-level Ruby plus our helpers, without polluting
+    # Object globally.
+    class ScriptHost
+      def initialize(connector_full_path, target_dir, connection_name)
+        @connector_full_path = connector_full_path
+        @target_dir          = target_dir
+        @connection_name     = connection_name || 'default'
+        @sdk_connector       = nil
+        @connection_loaded   = false
+        @connection_cached   = nil
+        @warned_settings     = false
+      end
+
+      # Hash of decrypted settings for the configured connection. Returns {}
+      # and emits a one-time warning if settings can't be loaded.
+      def connection
+        return @connection_cached if @connection_loaded
+
+        @connection_loaded = true
+        @connection_cached = load_connection
+      end
+
+      # Invoke a connector `methods:` entry. Args are forwarded to the lambda
+      # as-is. Returns the lambda's return value.
+      #
+      # Example:
+      #   call_method(:format_timestamp, Time.now)
+      def call_method(name, *args)
+        proxy = sdk_connector.methods
+        unless proxy.respond_to?(name.to_sym)
+          raise InvalidReturn, "No methods entry named '#{name}' found in connector."
+        end
+        proxy.public_send(name.to_sym, *args)
+      end
+
+      # Invoke a connector `pick_lists:` entry. `args` is a Hash of named
+      # arguments for dependent pick lists. The SDK supplies `connection` to
+      # the lambda automatically.
+      #
+      # Examples:
+      #   call_pick_list(:active_customers)
+      #   call_pick_list(:customer_orders, customer_id: 123)
+      def call_pick_list(name, **args)
+        proxy = sdk_connector.pick_lists
+        unless proxy.respond_to?(name.to_sym)
+          raise InvalidReturn, "No pick_lists entry named '#{name}' found in connector."
+        end
+        # SDK signature: pick_list_name(settings = nil, args = {})
+        # Passing nil for settings tells the SDK to reuse the connector's settings.
+        proxy.public_send(name.to_sym, nil, args)
+      end
+
+      private
+
+      def sdk_connector
+        @sdk_connector ||= Workato::Connector::Sdk::Connector.from_file(@connector_full_path, connection)
+      end
+
+      # Tries (in order): settings.yaml.enc + master.key, then settings.yaml.
+      # Uses Workato::Connector::Sdk::Settings so encryption is handled by the
+      # SDK's own loader (same path it uses for `wisco exec`). Returns {} and
+      # warns once on any failure.
+      def load_connection
+        enc_file  = File.join(@target_dir, 'settings.yaml.enc')
+        key_file  = File.join(@target_dir, 'master.key')
+        yaml_file = File.join(@target_dir, 'settings.yaml')
+
+        if File.exist?(enc_file) && File.exist?(key_file)
+          read_settings(enc_file) do |name|
+            Workato::Connector::Sdk::Settings.from_encrypted_file(enc_file, key_file, name)
+          end
+        elsif File.exist?(yaml_file)
+          read_settings(yaml_file) do |name|
+            Workato::Connector::Sdk::Settings.from_file(yaml_file, name)
+          end
+        else
+          warn_settings("No settings.yaml or settings.yaml.enc found in #{@target_dir}")
+          {}
+        end
+      end
+
+      # Reads settings using a Settings.from_* loader. Tries with the configured
+      # connection name first; if that key isn't present at the top level
+      # (KeyError), falls back to loading the whole file as a flat hash.
+      def read_settings(path)
+        hash = begin
+                 yield(@connection_name)
+               rescue KeyError
+                 yield(nil)
+               end
+        return {} unless hash.respond_to?(:to_h)
+
+        hash.to_h
+      rescue StandardError => e
+        warn_settings("Failed to load settings from #{path}: #{e.message}")
+        {}
+      end
+
+      def warn_settings(msg)
+        return if @warned_settings
+        @warned_settings = true
+        Wisco::TerminalOutput.emit_warning("[WARN] connection helper: #{msg}. Returning {}.")
+      end
+    end
+  end
+end

data/lib/wisco/version.rb

@@ -1,3 +1,3 @@
 module Wisco
-  VERSION = '0.3.6'
+  VERSION = '0.3.8'
 end

data/lib/wisco.rb

@@ -90,7 +90,7 @@ module Wisco
     option :input,      type: :string,  desc: 'Specific input file'
     option :pagination, type: :boolean, default: true,
                         desc: 'Triggers only: true = .poll (with pagination), false = .poll_page (without)'
-    option :verbose,    type: :boolean, default: true,  desc: 'Enable detailed SDK logging'
+    option :verbose,    type: :boolean, default: false, desc: 'Enable detailed SDK logging'
     option :extended,   type: :boolean, default: true,
                         desc: 'Auto-pass input_fields/output_fields as extended schema (actions/triggers)'
     option :closure,                  type: :string, desc: 'Closure JSON file (triggers: simulate subsequent polls)'
@@ -127,12 +127,15 @@ module Wisco
         get_users           auto-detect section
     DESC
     option :overwrite, type: :boolean, default: false, desc: 'Overwrite execute_input.json even if user-edited'
+    option :ruby,      type: :boolean, default: false,
+                       desc: 'Also scaffold an execute_input.rb template for dynamic input scripts'
     option :debug,     type: :boolean, default: false, desc: 'Print ExecCommand call details'
     def fixtures(path_arg, target_dir = nil)
       Wisco::Commands::Fixtures.run(
         path_arg,
         target_dir || Dir.pwd,
         overwrite: options[:overwrite],
+        ruby:      options[:ruby],
         debug:     options[:debug]
       )
     end
@@ -146,7 +149,7 @@ module Wisco
     option :title,   type: :string,  desc: 'Connector title (default: from config or connector code)'
     option :notes,   type: :string,  desc: 'Version notes (prompted if not provided)'
     option :folder,  type: :numeric, desc: 'Workato folder ID to push connector into'
-    option :verbose, type: :boolean, default: true,  desc: 'Enable detailed SDK logging'
+    option :verbose, type: :boolean, default: false, desc: 'Enable detailed SDK logging'
     option :debug,   type: :boolean, default: false, desc: 'Show push call details'
     def push(target_dir = nil)
       Wisco::Commands::Push.run(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wisco
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.8
 platform: ruby
 authors:
 - mbillington
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-06 00:00:00.000000000 Z
+date: 2026-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -77,6 +77,7 @@ files:
 - lib/wisco/commands/schema.rb
 - lib/wisco/config.rb
 - lib/wisco/connector.rb
+- lib/wisco/exec_script.rb
 - lib/wisco/path_utils.rb
 - lib/wisco/profile.rb
 - lib/wisco/terminal_output.rb