snippet_cli 0.3.6 → 0.5.2

data/lib/snippet_cli/banner.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'gum'
+
+module SnippetCli
+  FIGLET_ART = "┏━┓┏┓╻╻┏━┓┏━┓┏━╸╺┳╸   ┏━╸╻  ╻\n" \
+               "┗━┓┃┗┫┃┣━┛┣━┛┣╸  ┃    ┃  ┃  ┃\n" \
+               '┗━┛╹ ╹╹╹  ╹  ┗━╸ ╹    ┗━╸┗━╸╹'
+
+  def self.banner
+    Gum::Command.run_non_interactive(
+      'style', '--border=rounded', '--padding=1 2', '--align=center', '--border-foreground=075',
+      input: FIGLET_ART
+    )
+  end
+end

data/lib/snippet_cli/commands/check.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require_relative '../file_validator'
+require_relative '../ui'
+require_relative '../yaml_loader'
+require_relative '../yaml_line_resolver'
+require_relative '../table_formatter'
+require_relative '../wizard_helpers/error_handler'
+require_relative '../wizard_helpers/match_file_selector'
+require_relative '../espanso_config'
+
+module SnippetCli
+  module Commands
+    class Check < Dry::CLI::Command
+      include WizardHelpers::ErrorHandler
+      include WizardHelpers::MatchFileSelector
+
+      desc 'Check a match file against the Espanso schema (alias: k)'
+
+      option :file, aliases: ['-f'], desc: 'Path to the Espanso match YAML file to check'
+
+      def call(file: nil, **)
+        handle_errors(NoMatchFilesError) do
+          file ||= pick_match_file.last
+          data = YamlLoader.load(file)
+          report(file, FileValidator.errors_structured(data))
+        end
+      rescue FileMissingError, InvalidYamlError => e
+        warn e.message
+        exit 1
+      end
+
+      private
+
+      def report(file, errors)
+        return UI.success("#{file} is valid.") if errors.empty?
+
+        rows = errors.map do |e|
+          line = YamlLineResolver.resolve(file, e[:pointer])
+          [line || '?', e[:pointer].empty? ? '(root)' : e[:pointer], e[:message]]
+        end
+        warn "\e[38;5;231mValidation errors found:\e[0m"
+        warn TableFormatter.render(rows, headers: %w[Line Location Error])
+        exit 1
+      end
+    end
+  end
+end

data/lib/snippet_cli/commands/conflict.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'gum'
+require 'yaml'
+require_relative '../conflict_detector'
+require_relative '../ui'
+require_relative '../wizard_helpers/error_handler'
+require_relative '../wizard_helpers/match_file_selector'
+require_relative '../file_helper'
+require_relative '../espanso_config'
+
+module SnippetCli
+  module Commands
+    class Conflict < Dry::CLI::Command
+      include WizardHelpers::ErrorHandler
+      include WizardHelpers::MatchFileSelector
+
+      desc 'Detect duplicate triggers in a match file (alias: c)'
+
+      option :file,    aliases: ['-f'], desc: 'Path to Espanso match YAML file'
+      option :trigger, type: :array, aliases: ['-t'], desc: 'Trigger(s) to look up (comma-separated or repeated flag)'
+
+      def call(file: nil, trigger: nil, **)
+        handle_errors(NoMatchFilesError) { detect_conflicts(file, trigger) }
+      rescue FileMissingError => e
+        warn e.message
+        exit 1
+      rescue Psych::SyntaxError => e
+        warn "Invalid YAML: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def detect_conflicts(file, trigger)
+        file ||= pick_match_file.last
+        FileHelper.ensure_readable!(file)
+        entries = load_entries(file)
+        trigger ? show_trigger(entries, trigger) : show_conflicts(entries)
+      end
+
+      def load_entries(file)
+        ConflictDetector.extract_triggers(File.read(file))
+      end
+
+      def show_conflicts(entries)
+        duplicates = entries.group_by { |e| e[:trigger] }.select { |_, v| v.size > 1 }
+        if duplicates.empty?
+          puts 'No conflicts found'
+          return
+        end
+        UI.note('The following conflicts were found:')
+        Gum.table(build_rows(duplicates), columns: %w[Trigger Lines], separator: "\t", print: true)
+      end
+
+      def build_rows(groups)
+        groups.map do |trig, occurrences|
+          [trig, occurrences.map { |e| e[:line] }.join(', ')]
+        end
+      end
+
+      def show_trigger(entries, triggers)
+        matches = entries.select { |e| triggers.include?(e[:trigger]) }
+        if matches.empty?
+          puts "Trigger(s) #{triggers.join(', ')} not found"
+          return
+        end
+        UI.note('The following conflicts were found:')
+        rows = build_rows(matches.group_by { |e| e[:trigger] })
+        Gum.table(rows, columns: %w[Trigger Lines], separator: "\t", print: true)
+      end
+    end
+  end
+end

data/lib/snippet_cli/commands/new.rb

@@ -1,112 +1,26 @@
 # frozen_string_literal: true
-require 'bundler/setup'
-require 'tty-box'
-require 'tty-prompt'
-require_relative '../../snippet_generator'
-require 'httparty'
-require 'json'
-require 'ascii'
-# require 'snippets_for_espanso/SnippetGenerator'
-require_relative '../command'
 
+require 'dry/cli'
+require_relative '../new_workflow'
 
 module SnippetCli
   module Commands
-    class New < SnippetCli::Command
-            def show_banner()
-        box = TTY::Box::frame(width:67, height:11, border: :thick, align: :left) do 
-        "
-        #####   #     # ### ######  ######  ####### ####### 
-        #     # ##    #  #  #     # #     # #          #    
-        #       # #   #  #  #     # #     # #          #    
-         #####  #  #  #  #  ######  ######  #####      #    
-              # #   # #  #  #       #       #          #    
-        #     # #    ##  #  #       #       #          #    
-         #####  #     # ### #       #       #######    #    CLI                                                                
-        "
-        end
-        puts box
-      end
-      include SnippetGenerator
-      @leading = "                                      "
-      
-      prompt=TTY::Prompt.new
-      def initialize(options)
-        @options = options
-        @file_path = File.readlines("#{ENV["HOME"]}/snippet_cli_config.txt")[1]
-        @file_path = Ascii.process(@file_path)
-      end
-
-      def but_first()
-        puts @leading
-        puts "Now you'll enter what you want replaced."
-        puts @leading
-        puts "But first ..."
-        puts @leading
-        prompt.error("Don't use tabs. YAML hates them and it leads to unpredictable results.")
-        puts @leading
-      end
-
-      def new_form()
-          puts "Let's add a new snippet to your configuration"
-          puts @leading
-          snippet_type = prompt.select("Do you want a Snippet or a Snippet with a form?") do |menu|
-          menu.enum "."
+    class New < Dry::CLI::Command
+      desc 'Build an Espanso match entry interactively (alias: n)'
 
-          menu.choice "A snippet",1
-          menu.choice "A snippet with a form",2 
-          menu.choice "A snippet from Semplificato API",3
-          end
-          case snippet_type
-            when 1
-              puts @leading
-              snippet_trigger=prompt.ask("What do you want to type to trigger the snippet?")
-              puts @leading
-              puts "Okay, the snippet will be triggered by:"
-              prompt.ok( ":#{snippet_trigger}")
-              puts@leading
-              but_first()
-              replacement = prompt.multiline("what did you want the trigger to be replaced with?")
-              if (replacement.length() > 1)
-                single_snippet_export(@file_path,snippet_trigger,replacement)
-              else
-                single_snippet_export(@file_path,snippet_trigger,replacement[0])
-              end
-            when 2
-              puts @leading
-              snippet_trigger=prompt.ask("What do you want to type to trigger the snippet?")
-              puts @leading
-              puts "Okay, the snippet will be triggered by:"
-              prompt.ok( ":#{snippet_trigger}")
-              puts@leading
-              but_first()
-              newprompt = TTY::Prompt.new
-              newprompt.warn("For a form field wrap the word in double brackets.  Like {{example}}")
-              puts @leading
-              newprompt.ok("Also make sure the name of each form field is unique.")
-              puts @leading
-              replacement = prompt.multiline("what did you want the trigger to be replaced with?")
-                if (replacement.length() > 1)
-                  input_form_snippet_export(@file_path,snippet_trigger,replacement)
-                else
-                  input_form_snippet_export(@file_path,snippet_trigger,replacement[0])
-                end
-            when 3
-              puts @leading
-              url = prompt.ask("What's the URL of the snippet?",default: "http://localhost:3000/snippets/1")
-              json_url = url+(".json")
-              api_response=HTTParty.get(json_url)
-              response_parsed = api_response.body
-              single_snippet_export(@file_path,response_parsed['trigger'],response_parsed['replacement'])
-              puts@leading
-              prompt.ok("Added snippet from #{url}")
-            end
-      end
+      option :save,         type: :flag, default: false, aliases: ['-s'],
+                            desc: 'Save snippet to Espanso match file'
+      option :no_vars,      type: :flag, default: false, aliases: ['-n'],
+                            desc: 'Skip variables; supports alt types (image_path, markdown, html) and advanced options'
+      option :bare,         type: :flag, default: false, aliases: ['-b'],
+                            desc: 'Trigger(s) and plaintext only (single/multi-line); no vars, alt types, or advanced'
 
-      def execute(input: $stdin, output: $stdout)
-        # Command logic goes here ...
-        output.puts show_banner()
-        new_form()
+      def call(**opts)
+        if opts[:bare] && opts[:no_vars]
+          warn '--bare and --no-vars are mutually exclusive. Provide only one.'
+          exit 1
+        end
+        NewWorkflow.new.run(opts)
       end
     end
   end

data/lib/snippet_cli/commands/vars.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require_relative '../var_builder'
+require_relative '../vars_block_renderer'
+require_relative '../snippet_builder'
+require_relative '../ui'
+require_relative '../wizard_context'
+require_relative '../wizard_helpers/error_handler'
+require_relative '../wizard_helpers/match_file_selector'
+require_relative '../espanso_config'
+require_relative '../global_vars_writer'
+
+module SnippetCli
+  module Commands
+    class Vars < Dry::CLI::Command
+      include WizardHelpers::ErrorHandler
+      include WizardHelpers::MatchFileSelector
+
+      desc 'Build an Espanso vars block interactively (alias: v)'
+
+      option :save, type: :flag, default: false, aliases: ['-s'],
+                    desc: 'Save vars to Espanso match file under global_vars'
+
+      def call(**opts)
+        handle_errors(EspansoConfigError, NoMatchFilesError) do
+          context = WizardContext.new(pipe_output: SnippetCli.pipe_output)
+          result = VarBuilder.run(skip_initial_prompt: true)
+          save_vars(result[:vars]) if opts[:save]
+          deliver_vars(result[:vars], context)
+        end
+      end
+
+      private
+
+      def deliver_vars(vars, context)
+        UI.deliver(vars_yaml(vars), label: 'Vars', context: context)
+      end
+
+      def save_vars(vars)
+        return if vars.empty?
+
+        chosen, full_path = pick_match_file
+        entries = vars_yaml(vars).sub(/\Avars:\n/, '')
+        GlobalVarsWriter.append(full_path, entries)
+        UI.success("Saved to #{chosen}")
+      end
+
+      # pick_match_file is provided by WizardHelpers
+
+      def vars_yaml(vars)
+        return "vars: []\n" if vars.empty?
+
+        "#{VarsBlockRenderer.render(vars).join("\n")}\n"
+      end
+    end
+  end
+end

data/lib/snippet_cli/commands/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require_relative '../version'
+require_relative '../ui'
+
+module SnippetCli
+  module Commands
+    class Version < Dry::CLI::Command
+      desc 'Print the snippet_cli version'
+
+      def call(**)
+        UI.info("snippet_cli v#{SnippetCli::VERSION}")
+      end
+    end
+  end
+end

data/lib/snippet_cli/conflict_detector.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module SnippetCli
+  module ConflictDetector
+    TRIGGER_KEYS = %w[trigger triggers regex].freeze
+
+    def self.extract_triggers(content)
+      return [] if content.nil? || content.strip.empty?
+
+      doc = Psych.parse(content)
+      return [] unless doc
+
+      root = doc.root
+      return [] unless root.is_a?(Psych::Nodes::Mapping)
+
+      matches_seq = find_matches_sequence(root)
+      return [] unless matches_seq
+
+      extract_from_sequence(matches_seq)
+    end
+
+    def self.find_matches_sequence(mapping)
+      mapping.children.each_slice(2) do |key, value|
+        return value if key.is_a?(Psych::Nodes::Scalar) && key.value == 'matches'
+      end
+      nil
+    end
+    private_class_method :find_matches_sequence
+
+    def self.extract_from_sequence(sequence)
+      return [] unless sequence.is_a?(Psych::Nodes::Sequence)
+
+      sequence.children.each_with_object([]) do |match_node, entries|
+        next unless match_node.is_a?(Psych::Nodes::Mapping)
+
+        extract_from_mapping(match_node, entries)
+      end
+    end
+    private_class_method :extract_from_sequence
+
+    def self.extract_from_mapping(mapping, entries)
+      mapping.children.each_slice(2) do |key, value|
+        next unless key.is_a?(Psych::Nodes::Scalar)
+
+        extract_key_value(key.value, value, entries)
+      end
+    end
+    private_class_method :extract_from_mapping
+
+    def self.extract_key_value(key, value, entries)
+      case key
+      when 'trigger', 'regex'
+        entries << { trigger: value.value, line: value.start_line + 1 } if value.is_a?(Psych::Nodes::Scalar)
+      when 'triggers'
+        extract_triggers_array(value, entries)
+      end
+    end
+    private_class_method :extract_key_value
+
+    def self.extract_triggers_array(sequence, entries)
+      return unless sequence.is_a?(Psych::Nodes::Sequence)
+
+      sequence.children.each do |scalar|
+        entries << { trigger: scalar.value, line: scalar.start_line + 1 } if scalar.is_a?(Psych::Nodes::Scalar)
+      end
+    end
+    private_class_method :extract_triggers_array
+  end
+end

data/lib/snippet_cli/cursor_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'tty-cursor'
+
+module SnippetCli
+  # Utility for TTY cursor manipulation.
+  module CursorHelper
+    # Returns a lambda that erases `line_count` lines upward when called.
+    # Returns a no-op lambda when stdout is not a TTY.
+    def self.build_erase_lambda(line_count)
+      return -> {} unless $stdout.tty?
+
+      lambda {
+        $stdout.print TTY::Cursor.up(line_count)
+        $stdout.print "\r"
+        $stdout.print TTY::Cursor.clear_screen_down
+      }
+    end
+  end
+end

data/lib/snippet_cli/espanso_config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module SnippetCli
+  class EspansoConfigError < StandardError; end
+
+  # Discovers Espanso config paths by shelling out to `espanso path`.
+  module EspansoConfig
+    # Returns the match directory path (e.g. ~/.config/espanso/match).
+    def self.match_dir
+      output, status = Open3.capture2('espanso', 'path')
+      raise EspansoConfigError, 'Could not determine Espanso config path. Is espanso installed?' unless status.success?
+
+      config_line = output.lines.find { |l| l.start_with?('Config:') }
+      raise EspansoConfigError, 'Could not determine Espanso config path from `espanso path` output.' unless config_line
+
+      File.join(config_line.split(':', 2).last.strip, 'match')
+    end
+
+    # Returns sorted list of .yml files in the match directory.
+    def self.match_files
+      Dir.glob(File.join(match_dir, '**', '*.yml'), sort: true)
+    end
+  end
+end

data/lib/snippet_cli/file_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SnippetCli
+  # Utility methods for safe file reading.
+  module FileHelper
+    # Checks that path exists. Raises FileMissingError if not.
+    def self.ensure_readable!(path)
+      raise FileMissingError, "File not found: #{path}" unless File.exist?(path)
+    end
+
+    # Returns the contents of path if it exists, or an empty string otherwise.
+    def self.read_or_empty(path)
+      File.exist?(path) ? File.read(path) : ''
+    end
+  end
+end

data/lib/snippet_cli/file_validator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'hash_utils'
+require_relative 'schema_validator'
+
+module SnippetCli
+  # Validates a full Espanso match file (matches array + global_vars + imports + anchors)
+  # against the vendored merged schema (official + custom extensions).
+  module FileValidator
+    # Returns true if the data hash is valid against the matchfile schema.
+    def self.valid?(data)
+      SchemaValidator.valid?(HashUtils.stringify_keys_deep(data))
+    end
+
+    # Returns an array of human-readable error strings with field pointers.
+    # Empty array means the data is valid.
+    def self.errors(data)
+      errors_structured(data).map do |e|
+        e[:pointer].empty? ? e[:message] : "at #{e[:pointer]}: #{e[:message]}"
+      end
+    end
+
+    # Returns an array of structured error hashes: { pointer: String, message: String }.
+    # Empty array means the data is valid.
+    def self.errors_structured(data)
+      SchemaValidator.validate(HashUtils.stringify_keys_deep(data)).map do |error|
+        pointer = error['data_pointer'].to_s
+        message = error['error'] || error.fetch('type', 'validation error')
+        { pointer: pointer, message: message }
+      end
+    end
+  end
+end

data/lib/snippet_cli/file_writer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SnippetCli
+  # Shared file-writing interface for all Espanso file writers.
+  # Centralises the write operation so file-safety behaviors (e.g. atomic write)
+  # need only be added here.
+  module FileWriter
+    def self.write(path, content)
+      File.write(path, content)
+    end
+  end
+end

data/lib/snippet_cli/form_field_parser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SnippetCli
+  # Parses [[field_name]] placeholders from form variable layout strings.
+  module FormFieldParser
+    PATTERN = /\[\[\s*(\w+)\s*\]\]/
+
+    # Returns an array of field name strings extracted from the layout.
+    def self.extract(layout)
+      layout.to_s.scan(PATTERN).flatten
+    end
+  end
+end

data/lib/snippet_cli/global_vars_formatter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'string_helper'
+
+module SnippetCli
+  # Pure formatting logic for the global_vars section of an Espanso match file.
+  # Operates entirely on strings — no file I/O.
+  module GlobalVarsFormatter
+    # Returns updated file content with var_entries appended under global_vars.
+    # Creates the global_vars key if absent. Never overwrites existing vars.
+    # +existing+ is the current file content (or empty string).
+    # +var_entries+ is the pre-indented YAML string for the new vars.
+    def self.build_content(existing, var_entries)
+      return new_global_vars(var_entries) if existing.strip.empty?
+      return insert_into_block(existing, var_entries) if existing.match?(/^global_vars:\s*$/m)
+
+      append_global_vars(existing, var_entries)
+    end
+
+    def self.new_global_vars(var_entries)
+      StringHelper.ensure_trailing_newline("global_vars:\n#{var_entries}")
+    end
+    private_class_method :new_global_vars
+
+    def self.append_global_vars(existing, var_entries)
+      StringHelper.ensure_trailing_newline("#{existing.chomp}\n\nglobal_vars:\n#{var_entries}")
+    end
+    private_class_method :append_global_vars
+
+    def self.insert_into_block(existing, var_entries)
+      lines = existing.lines
+      gv_index = lines.index { |l| l.match?(/^global_vars:\s*$/) }
+      last_content = find_block_end(lines, gv_index)
+
+      join_parts(lines, last_content, var_entries)
+    end
+    private_class_method :insert_into_block
+
+    def self.find_block_end(lines, gv_index)
+      last_content = gv_index
+      ((gv_index + 1)...lines.length).each do |i|
+        break if lines[i].match?(/^\S/)
+
+        last_content = i unless lines[i].strip.empty?
+      end
+      last_content
+    end
+    private_class_method :find_block_end
+
+    def self.join_parts(lines, last_content, var_entries)
+      before = lines[0..last_content].join
+      rest = lines[(last_content + 1)..]
+
+      result = "#{before.chomp}\n#{var_entries}"
+      if rest && !rest.empty?
+        result << "\n" unless result.end_with?("\n\n") || rest.first&.strip&.empty?
+        result << rest.join
+      end
+      StringHelper.ensure_trailing_newline(result)
+    end
+    private_class_method :join_parts
+  end
+end

data/lib/snippet_cli/global_vars_writer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'file_helper'
+require_relative 'file_writer'
+require_relative 'global_vars_formatter'
+
+module SnippetCli
+  # Thin I/O wrapper around GlobalVarsFormatter.
+  # Reads from and writes to Espanso match files; delegates all formatting logic.
+  module GlobalVarsWriter
+    # Appends var entries under the global_vars key in the given file.
+    # Creates the key if it doesn't exist. Never overwrites existing vars.
+    # +var_entries+ is the indented YAML string (each line already indented by 2).
+    def self.append(file_path, var_entries)
+      existing = FileHelper.read_or_empty(file_path)
+      content = GlobalVarsFormatter.build_content(existing, var_entries)
+      FileWriter.write(file_path, content)
+    end
+
+    # Returns an array of var name strings from the global_vars key in the file.
+    def self.read_names(file_path)
+      return [] unless File.exist?(file_path)
+
+      data = YAML.safe_load_file(file_path, permitted_classes: [Symbol]) || {}
+      Array(data['global_vars']).filter_map { |v| v['name'] }
+    end
+  end
+end

data/lib/snippet_cli/gum_theme.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SnippetCli
+  # Applies Gum color overrides via environment variables.
+  module GumTheme
+    COLORS = {
+      # gum confirm
+      'GUM_CONFIRM_PROMPT_FOREGROUND' => '231',
+      'GUM_CONFIRM_SELECTED_FOREGROUND' => '#F2D07C',
+      'GUM_CONFIRM_SELECTED_BACKGROUND' => '#6B7A90',
+
+      # gum choose — replaces default purple cursor (used for trigger type)
+      'GUM_CHOOSE_CURSOR_FOREGROUND' => '#8CAAED',
+      'GUM_CHOOSE_SELECTED_FOREGROUND' => '#A5D18A',
+      'GUM_CHOOSE_HEADER_FOREGROUND' => '231',
+
+      # gum filter — replaces default purple indicator and pink match highlight
+      'GUM_FILTER_INDICATOR_FOREGROUND' => '#8CAAED',
+      'GUM_FILTER_MATCH_FOREGROUND' => '#E88284',
+      'GUM_FILTER_SELECTED_FOREGROUND' => '#A5D18A',
+      'GUM_FILTER_PROMPT_FOREGROUND' => '#8CAAED',
+      'GUM_FILTER_HEADER_FOREGROUND' => '231',
+
+      # gum input — replaces default purple cursor
+      'GUM_INPUT_CURSOR_FOREGROUND' => '#8CAAED',
+      'GUM_INPUT_PROMPT_FOREGROUND' => '#8CAAED',
+      'GUM_INPUT_HEADER_FOREGROUND' => '231',
+
+      # gum write — replaces default purple cursor
+      'GUM_WRITE_CURSOR_FOREGROUND' => '#8CAAED',
+      'GUM_WRITE_PROMPT_FOREGROUND' => '#8CAAED',
+      'GUM_WRITE_HEADER_FOREGROUND' => '231'
+    }.freeze
+
+    def self.apply!
+      COLORS.each { |key, val| ENV[key] = val }
+    end
+  end
+end