wisco 0.3.8 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6489b0aaac5c9626f27141afebc7b4dda9b087c2cf94fee0744b9b603de4953
-  data.tar.gz: 298e1469cd688e9d824fd091d32ea84526934637b96e92a4ea19243dfb715e49
+  metadata.gz: 9d0223c07b265d6b699acec69facb0abc3cded752a3b99791454507bf8623490
+  data.tar.gz: 82b76acb11a65728840067d60bb809f0fb4f88421b0efeac922b967915cef2dc
 SHA512:
-  metadata.gz: 4b711094e3bf5990c6a591a9a75356660c86d813a76df331f101c8cf48ecbf3d98edcf9f4ede28c4c3cff1448f19991ef89383a1fecb5c78c8a21a3b1a1ce88c
-  data.tar.gz: 1581e25abeb992cb6eee659407561df32a47ecbe2cacacf9bb5ea55650eabe27015114c97cf6d5f5bcbba4acbf5593416c1bb5b37ca612f682b7095ba3708ccb
+  metadata.gz: 91cae2af261537aa28ab79a66f817fc4095f06c7d2f7cc16281e181872e4d5101b09386cc31793b1d8da09dbf03040946d2b162c41d3705062c4a7b77a5bd7a9
+  data.tar.gz: 8355aa7b644b559c082d656ca19134b3af9c3a2803f1e31ba7e27b4a31d11af9ea1788a558f259e69d7c4d0af88b5e6f27abf19d223b312c1aa1c273cda93d9b

data/lib/wisco/commands/exec.rb

@@ -6,6 +6,7 @@ require_relative '../config'
 require_relative '../connector'
 require_relative '../path_utils'
 require_relative '../exec_script'
+require_relative 'fixtures'
 
 module Wisco
   module Commands
@@ -14,7 +15,8 @@ module Wisco
 
       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)
+              extended_input_schema: nil, extended_output_schema: nil,
+              summary: true, summary_lines: 20)
         target_dir = File.expand_path(target_dir)
         config_path = Wisco.config_path(target_dir)
 
@@ -51,12 +53,12 @@ module Wisco
           fixture_dir_output = fixtures_dir.sub(connector_path, '.')
 
           unless File.directory?(fixtures_dir)
-            Wisco::TerminalOutput.emit_error("Error: fixtures directory not found: #{fixture_dir_output}")
-            Wisco::TerminalOutput.emit_error("       Run '#{Wisco::CLI_NAME} fixtures #{section}.#{key}' first.")
-            next
+            puts "  Auto-setup: running fixtures for #{section}.#{key}"
+            Wisco::Commands::Fixtures.run("#{section}.#{key}", target_dir, debug: debug)
           end
 
           input_files = resolve_input_files(input, fixtures_dir, debug: debug)
+          batch = pairs.length > 1 || input_files.length > 1
 
           if input_files.empty?
             if %w[pick_lists methods].include?(section)
@@ -65,9 +67,14 @@ module Wisco
                           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)
+                          extended_output_schema: extended_output_schema, debug: debug,
+                          summary: summary, summary_lines: summary_lines, batch: batch)
             else
               Wisco::TerminalOutput.emit_warning("  Warning: No ready input files found in #{fixture_dir_output}")
+              input_template = File.join(fixtures_dir, 'execute_input.json')
+              if File.exist?(input_template)
+                Wisco::TerminalOutput.emit_info("           Fill in #{File.join(fixture_dir_output, 'execute_input.json')} and re-run.")
+              end
             end
             next
           end
@@ -79,13 +86,15 @@ module Wisco
                                   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)
+                                  extended_output_schema: extended_output_schema, debug: debug,
+                                  summary: summary, summary_lines: summary_lines, batch: batch)
             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)
+                          extended_output_schema: extended_output_schema, debug: debug,
+                          summary: summary, summary_lines: summary_lines, batch: batch)
             end
           end
         end
@@ -184,7 +193,8 @@ module Wisco
       def execute_one(section, key, input_file, fixtures_dir, connector_full_path, connection,
                       pagination: true, verbose: false, debug: false,
                       extended: true, closure: nil, config_fields: nil, continue: nil,
-                      extended_input_schema: nil, extended_output_schema: nil)
+                      extended_input_schema: nil, extended_output_schema: nil,
+                      summary: true, summary_lines: 20, batch: false)
         stem        = input_file ? File.basename(input_file, '.*') : 'execute'
         output_file = File.join(fixtures_dir, "output_#{stem}.json")
         error_file  = File.join(fixtures_dir, "error_#{stem}.txt")
@@ -265,12 +275,14 @@ module Wisco
         end
 
         FileUtils.rm_f(error_file)
-
         return unless File.exist?(output_file)
 
-        pretty = JSON.pretty_generate(JSON.parse(File.read(output_file)))
+        parsed = JSON.parse(File.read(output_file))
+        pretty = JSON.pretty_generate(parsed)
         File.write(output_file, pretty + "\n")
         puts "  Written: #{output_file}"
+        display_output_summary(parsed, pretty, section: section, summary: summary,
+                               summary_lines: summary_lines, batch: batch)
       end
 
       # Handles `execute_*.rb` scripts: evaluates the script to produce dynamic
@@ -282,7 +294,8 @@ module Wisco
                               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)
+                              extended_input_schema: nil, extended_output_schema: nil,
+                              summary: true, summary_lines: 20, batch: false)
         subdir      = File.join(fixtures_dir, File.basename(script_path, '.rb'))
         FileUtils.mkdir_p(subdir)
         input_file  = File.join(subdir, 'input.json')
@@ -377,14 +390,88 @@ module Wisco
         end
 
         FileUtils.rm_f(error_file)
-
         return unless File.exist?(output_file)
 
-        pretty = JSON.pretty_generate(JSON.parse(File.read(output_file)))
+        parsed = JSON.parse(File.read(output_file))
+        pretty = JSON.pretty_generate(parsed)
         File.write(output_file, pretty + "\n")
         puts "  Written: #{output_file}"
+        display_output_summary(parsed, pretty, section: section, summary: summary,
+                               summary_lines: summary_lines, batch: batch)
+      end
+
+      # ── Output summary ─────────────────────────────────────────────────────
+
+      def display_output_summary(parsed, pretty, section:, summary:, summary_lines:, batch:)
+        return unless summary
+
+        if section == 'pick_lists'
+          if batch
+            count = parsed.is_a?(Array) ? parsed.length : '?'
+            puts "  Items: #{count}"
+          else
+            display_pick_list_table(parsed)
+          end
+          return
+        end
+
+        puts pretty if !batch && pretty.lines.length <= (summary_lines || 20)
+        puts "  #{format_summary(parsed)}"
+      end
+
+      def display_pick_list_table(data)
+        unless data.is_a?(Array) && !data.empty?
+          puts '  (empty)'
+          return
+        end
+
+        rows = data.select { |item| item.is_a?(Array) && item.length >= 2 }
+
+        if rows.empty?
+          puts "  Items: #{data.length} (unexpected format)"
+          return
+        end
+
+        max_col = 60
+        labels  = rows.map { |item| truncate_str(item[0].to_s, max_col) }
+        values  = rows.map { |item| truncate_str(item[1].to_s, max_col) }
+
+        col1_w = [labels.map(&:length).max, 'Label'.length].max
+        col2_w = [values.map(&:length).max, 'Value'.length].max
+        num_w  = rows.length.to_s.length
+
+        puts "  Items: #{rows.length}"
+        puts "  | #{'#'.ljust(num_w)} | #{'Label'.ljust(col1_w)} | #{'Value'.ljust(col2_w)} |"
+        puts "  |#{'-' * (num_w + 2)}|#{'-' * (col1_w + 2)}|#{'-' * (col2_w + 2)}|"
+        rows.each_with_index do |_, i|
+          puts "  | #{(i + 1).to_s.ljust(num_w)} | #{labels[i].ljust(col1_w)} | #{values[i].ljust(col2_w)} |"
+        end
+      end
+
+      def format_summary(parsed)
+        case parsed
+        when Array
+          return 'Array: 0 items' if parsed.empty?
+          first_str = parsed.first.inspect
+          first_str = "#{first_str[0, 97]}…" if first_str.length > 100
+          "Array: #{parsed.length} #{parsed.length == 1 ? 'item' : 'items'} — first: #{first_str}"
+        when Hash
+          return 'Hash: 0 keys' if parsed.empty?
+          keys   = parsed.keys.first(20)
+          suffix = parsed.keys.length > 20 ? " (+#{parsed.keys.length - 20} more)" : ''
+          "Hash: #{parsed.keys.length} keys — #{keys.join(', ')}#{suffix}"
+        when NilClass
+          '(nil)'
+        else
+          "Value: #{parsed.inspect}"
+        end
+      end
+
+      def truncate_str(str, max)
+        str.length > max ? "#{str[0, max - 1]}…" : str
       end
 
+      # ── SDK array-args normalisation ───────────────────────────────────────
       # 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

data/lib/wisco/commands/list.rb

@@ -12,9 +12,14 @@ module Wisco
 
       module_function
 
-      def run(subcommand, target, sort: nil)
+      def run(subcommand, target, sort: nil, format: nil)
         validate_sort!(sort)
 
+        if format
+          run_formatted(target, format: format)
+          return
+        end
+
         case subcommand
         when nil        then run_tree(target)
         when 'actions'  then run_actions(target, sort: sort)
@@ -93,6 +98,69 @@ module Wisco
         run_triggers(target_dir, sort: sort)
       end
 
+      # ---------------------------------------------------------------------------
+      # Machine-readable output
+      # ---------------------------------------------------------------------------
+
+      def run_formatted(target_dir, format:)
+        require 'yaml' if format.downcase == 'yaml'
+        connector = Wisco::Connector.load_connector_from_config(target_dir)
+        data = build_connector_hash(connector)
+        if format.downcase == 'yaml'
+          puts data.to_yaml
+        else
+          puts JSON.pretty_generate(data)
+        end
+      end
+
+      def build_connector_hash(connector)
+        {
+          'title'      => connector[:title].to_s,
+          'connection' => build_connection(connector[:connection]),
+          'actions'    => build_section(connector[:actions]),
+          'triggers'   => build_section(connector[:triggers]),
+          'methods'    => (connector[:methods]    || {}).keys.map(&:to_s).sort,
+          'pick_lists' => (connector[:pick_lists] || {}).keys.map(&:to_s).sort
+        }
+      end
+
+      def build_connection(conn)
+        return { 'fields' => [] } unless conn.is_a?(Hash)
+
+        fields = conn[:fields] || []
+        { 'fields' => fields.map { |f| safe_serialize(f) }.compact }
+      end
+
+      def build_section(section)
+        return {} unless section.is_a?(Hash)
+
+        section.keys.sort_by(&:to_s).each_with_object({}) do |key, h|
+          item = section[key]
+          h[key.to_s] = {
+            'title'    => title_for(key, item),
+            'subtitle' => subtitle_for(item).to_s
+          }
+        end
+      end
+
+      # Recursively converts a connector value to a JSON-safe structure.
+      # Proc/lambda values are dropped (returned as nil so callers can compact).
+      def safe_serialize(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(k, v), h|
+            next if v.is_a?(Proc)
+
+            serialized = safe_serialize(v)
+            h[k.to_s] = serialized
+          end
+        when Array  then value.map { |v| safe_serialize(v) }
+        when Proc   then nil
+        when Symbol then value.to_s
+        else             value
+        end
+      end
+
       # ---------------------------------------------------------------------------
       # List utilities
       # ---------------------------------------------------------------------------

data/lib/wisco/version.rb

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

data/lib/wisco.rb

@@ -68,13 +68,14 @@ module Wisco
         all       Show tree + actions + triggers
       PATH defaults to the current directory.
     DESC
-    option :sort, type: :string, desc: 'Sort actions/triggers by key or title', enum: %w[key title]
+    option :sort,   type: :string, desc: 'Sort actions/triggers by key or title', enum: %w[key title]
+    option :format, type: :string, desc: 'Machine-readable output format (use with "all")', enum: %w[json yaml]
     def list(subcommand = nil, path = nil)
       if subcommand&.match?(%r{^[./~\\]|^[A-Za-z]:[/\\]})
         path = subcommand
         subcommand = nil
       end
-      Wisco::Commands::List.run(subcommand, path || Dir.pwd, sort: options[:sort])
+      Wisco::Commands::List.run(subcommand, path || Dir.pwd, sort: options[:sort], format: options[:format])
     end
 
     desc 'exec PATH [TARGET_DIR]', 'Execute connector methods against fixture data'
@@ -98,7 +99,9 @@ module Wisco
     option :continue,                 type: :string, desc: 'Continue JSON file (multistep actions)'
     option :'extended-input-schema',  type: :string, desc: 'Extended input schema JSON (overrides --extended auto-detection)'
     option :'extended-output-schema', type: :string, desc: 'Extended output schema JSON (overrides --extended auto-detection)'
-    option :debug,      type: :boolean, default: false, desc: 'Print ExecCommand call details'
+    option :debug,         type: :boolean, default: false, desc: 'Print ExecCommand call details'
+    option :summary,       type: :boolean, default: true,  desc: 'Show output summary after execution (use --no-summary to disable)'
+    option :'summary-lines', type: :numeric, default: 20,  desc: 'Max output lines to display in full before switching to summary-only'
     def exec(path_arg, target_dir = nil)
       Wisco::Commands::Exec.run(
         path_arg,
@@ -112,7 +115,9 @@ module Wisco
         continue:               options[:continue],
         extended_input_schema:  options[:extended_input_schema],
         extended_output_schema: options[:extended_output_schema],
-        debug:                  options[:debug]
+        debug:                  options[:debug],
+        summary:                options[:summary],
+        summary_lines:          options[:'summary-lines']
       )
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wisco
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.4.0
 platform: ruby
 authors:
 - mbillington
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-13 00:00:00.000000000 Z
+date: 2026-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport