jtag 0.1.21 → 0.2.0

data/bin/jtag

@@ -10,85 +10,123 @@ program_desc "Autotagging for Jekyll"
 
 version Jtag::VERSION
 
+@config_files = %w{blacklist.txt config.yml stopwords.txt synonyms.yml}
+@config_target = File.expand_path("~/.config/jtag")
 @piped_content = nil
 
-##
-## Define global flags and switches
-##
-desc "Expect input from STDIN to be null (0)-delimited: Useful for piping file lists from `find` or `grep`"
-default_value false
-switch %i[0 null], negatable: false
+def config_files_complete?
+  @config_files.each do |file|
+    return false unless File.exist?(File.join(@config_target, file))
+  end
+  true
+end
 
-desc "Path to alternate configuration directory"
-arg_name "config_dir"
-flag %i[c config_dir], :type => String
+class ::String
+  def file_list?
+    self.strip.split("\n").each do |line|
+      return false unless File.exist?(line)
+    end
+    true
+  end
+end
 
-desc "Debug level: Set the debug level for the application. 0 is silent, 1 is errors only, 2 is errors and warnings, 3 is errors, warnings and info"
+desc "Debug level"
+default_value "0"
 arg_name "debug_level"
-flag %i[d debug], :must_match => /\d+/, :type => Integer, :default_value => 3
+flag %i[d debug], :must_match => /\d+/, :type => Integer, :default_value => 0
 
-desc "Perform case-insensitive matches and searches: Useful for case-insensitive filesystems or when you're not sure of the case of your tags"
-switch %i[i case_insensitive], negatable: false
+desc "Run silently"
+switch %i[s silent]
 
-desc "Run silently: Suppress all output to STDOUT, same as debug level 0"
-switch %i[s silent], negatable: false
+desc "Perform case-insensitive matches and searches"
+switch %i[i case_insensitive]
 
-desc "Test (dry run, don't update files): Run all commands and show results on the command line, but don't overwrite/update any files"
+desc "Test (dry run, don't update files)"
+long_desc "Run all commands and show results on the command line, but don't overwrite/update any files"
 default_value false
-switch %i[t test], negatable: false
+switch %i[t test]
 
-# Add a command to update and notify the user of the configuration files location
-desc "Update and notify user of configuration files location"
-command :config do |c|
-  # Add a switch to reset all configuration files to default values
-  c.desc "Reset all configuration files to default values"
-  c.switch %i[r reset]
+def console_log(msg = "", options = {})
+  err = options[:err] || false
+  options[:log] ||= false
 
-  c.desc "Ignore prompts and answer yes to all questions."
-  c.switch %i[y yes], negatable: false
+  if options[:log]
+    if err
+      @log.warn(msg)
+    else
+      @log.info(msg)
+    end
+  end
 
-  c.desc "Set a specific configuration value"
-  c.arg_name "key"
-  c.flag %i[s set]
+  return if @silent
 
-  c.desc "The value to set for key"
-  c.arg_name "value"
-  c.flag %i[v value]
+  unless err
+    $stdout.puts msg
+  else
+    warn msg
+  end
+end
 
-  # Skip the pre block for this command
-  c.skips_pre
+def migrate_old_config
+  old_config = File.expand_path("~/.jtag")
+  new_config = File.expand_path("~/.config/jtag")
+
+  if File.directory?(old_config) && !File.directory?(new_config)
+    # Create parent directory if needed
+    FileUtils.mkdir_p(File.dirname(new_config))
+
+    # Move the directory
+    FileUtils.mv(old_config, new_config)
+
+    # ANSI color codes: yellow=\033[0;33m, boldyellow=\033[1;33m, default=\033[0;39m
+    console_log "\033[0;33mConfiguration directory has been moved from \033[1;33m~/.jtag\033[0;33m to \033[1;33m~/.config/jtag\033[0;33m.\033[0;39m", :err => true
+    console_log "\033[0;33mYour existing configuration and files have been preserved.\033[0;39m", :err => true
+  end
+end
+
+desc "Update and notify user of configuration files location"
+command :config do |c|
+  c.desc "Reset all configuration files to default values"
+  c.switch [:r, "reset"]
 
-  # Define the action to be taken when the command is executed
+  c.skips_pre
   c.action do |global_options, options, args|
-    if options[:set]
-      config = YAML.load_file(File.join(@util.config_target, "config.yml"))
-      config[options[:set]] = options[:value]
-      File.open(File.join(@util.config_target, "config.yml"), "w") do |f|
-        f.write(config.to_yaml)
+    if options[:r]
+      print "Are you sure you want to reset all config files? y/N: "
+      response = STDIN.gets.strip
+      if response =~ /^y/i
+        write_config(true)
+        console_log "Config files reset"
       end
-      return
+    else
+      write_config(false)
     end
+  end
+end
 
-    if options[:reset]
-      # Prompt the user for confirmation before resetting config files
-      if options[:yes]
-        res = true
-      else
-        print "Are you sure you want to reset all config files? y/N: "
-        response = STDIN.gets.strip
-        res = response =~ /^y/i
-      end
+def write_config(atomic = false)
+  gem_root = Gem.loaded_specs["jtag"].full_gem_path
+  gem_lib = File.join(gem_root, "lib")
+  config_source = File.join(gem_lib, "/jtag/config_files")
 
-      if res
-        # Reset config files to default values
-        @util.write_config(true)
-        @util.console_log "Config files reset"
-      end
-    else
-      # Update config files without overwriting existing files
-      @util.write_config(false)
+  unless File.directory?(@config_target) || atomic
+    FileUtils.cp_r(config_source, @config_target)
+    console_log "Configuration files are located in the folder: " + @config_target
+    console_log %Q{Make sure that "tags_location" in config.yml is set to your tags.json url.}
+    console_log "Configuration files written to #{@config_target}"
+  end
+
+  @config_files.each do |file|
+    unless File.exist?(File.join(@config_target, file))
+      source_file = File.join(config_source, file)
+      target_file = File.join(@config_target, file)
+      FileUtils.cp(source_file, target_file)
+      console_log "Config file #{file} added."
     end
   end
+  console_log
+  console_log "Configuration files are located in the folder: " + @config_target
+  console_log %Q{Make sure that "tags_location" in the config.yml file is set to your tags json file.}
 end
 
 desc "List tags, optionally filter for keywords/regular expressions (OR)"
@@ -105,125 +143,32 @@ command :search do |c|
   c.default_value false
   c.switch %i[c counts]
 
-  c.desc "Boolean operator for multiple tags (AND/OR/NOT)"
-  c.arg_name "bool"
-  c.default_value "OR"
-  c.flag %i[b bool], :must_match => /^([aon])(?:.*)$/i, :type => String
-
-  c.desc "Match type: exact, fuzzy, starts_with, contains"
-  c.arg_name "match_type"
-  c.default_value "contains"
-  c.flag %i[m match], :must_match => /^([exfsc])(?:.*)$/i, :type => String
-
-  c.desc "Case-sensitive matching"
-  c.switch %i[I s case_sensitive], negatable: true
-
-  c.desc "Fuzzy match distance"
-  c.arg_name "distance"
-  c.default_value 2
-  c.flag %i[d distance], :must_match => /^\d+$/, :type => Integer
-
   c.action do |global_options, options, args|
-    # Initialize arrays to store files and keywords
-    files = []
-    keywords = []
-    bool_op = options[:bool].to_bool
-
-    # Iterate over the arguments and separate files from keywords
-    args.length.times do
-      arg = args.pop
-      if File.file?(File.expand_path(arg))
-        files.push(File.expand_path(arg))  # Add existing files to the files array
-      else
-        keywords.push(arg)  # Add non-file arguments to the keywords array
-      end
-    end
-
-    # If piped content is provided and it is a list of files, add them to the files array
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
-
-    # If no files are provided, use the default post location
-    if files.empty?
-      if File.exist?(File.expand_path(@jt.tags_loc))
-        files = nil
-      else
-        if @jt.default_post_location && File.exist?(File.expand_path(@jt.default_post_location))
-          # Retrieves a list of files from the default post location with the specified post extension.
-          # The files are located using a glob pattern that matches all files with the given extension.
-          #
-          # @return [Array<String>] an array of file paths matching the specified pattern
-          files = Dir.glob(File.join(File.expand_path(@jt.default_post_location), "**", "*.#{@jt.post_extension}"))
+    tags = @jt.get_tags({ :counts => true })
+    if args.length > 0
+      re = args.join("|")
+      tags.delete_if { |tag|
+        if tag && tag["name"] =~ /(#{re})/i
+          false
+        else
+          true
         end
-      end
-    else
-      tags = {}
-    end
-
-    # Get tags with counts for the specified files
-    if @piped_content && !@piped_content.file_list?(global_options[:null])
-      if @piped_content.yaml?
-        tags = YAML.load(@piped_content).to_counts
-      elsif @piped_content.json?
-        tags = JSON.parse(@piped_content).to_counts
-      elsif @piped_content.tag_list?
-        tags = @piped_content.split("\n").map(&:strip).to_counts
+      }
+      if options[:c]
+        tags.map! { |tag| "#{tag["name"]} (#{tag["count"]})" }
       else
-        tags = @jt.tags({ :counts => true, :files => files })
+        tags.map! { |tag| tag["name"] }
       end
+      output_tags(tags, { :format => options[:format] })
     else
-      tags = @jt.tags({ :counts => true, :files => files })
-    end
-
-    exit_now! "No source tag list found" if !tags || tags.empty?
-
-    match_options = {
-      exact: false,
-      contains: false,
-      starts_with: false,
-      fuzzy: false,
-      case_sensitive: options[:case_sensitive],
-      distance: options[:distance],
-    }
-
-    if options[:match] =~ /^[ex]/i
-      match_options[:exact] = true
-    elsif options[:match] =~ /^s/i
-      match_options[:starts_with] = true
-    elsif options[:match] =~ /^f/i
-      match_options[:fuzzy] = true
-    else
-      match_options[:contains] = true
-    end
-
-    # If keywords are provided, filter tags based on the keywords
-    if keywords.length > 0
-      if bool_op == :and
-        tags.delete_if { |tag| tag && !keywords.all? { |keyword| tag["name"].match_keyword(keyword, match_options) } }
-      elsif bool_op == :not
-        re = keywords.join("|")  # Join keywords with OR operator
-        # Remove tags that match the keywords
-        tags.delete_if { |tag| tag && keywords.any? { |keyword| tag["name"].match_keyword(keyword, match_options) } }
+      tags.delete_if { |tag| !tag }
+      if options[:c]
+        tags.map! { |tag| "#{tag["name"]} (#{tag["count"]})" }
       else
-        # :or
-        # Filter tags based on any keywords
-        tags.delete_if { |tag| tag && !keywords.any? { |keyword| tag["name"].match_keyword(keyword, match_options) } }
+        tags.map! { |tag| tag["name"] }
       end
+      output_tags(tags, { :format => options[:format] })
     end
-
-    # Remove nil and false values from the tags array
-    tags.delete_if { |tag| !tag }
-
-    exit_now! "No matching tags found" if tags.nil? || tags.empty?
-
-    # Format tags with counts if the counts option is enabled
-    if options[:count]
-      tags.map! { |tag| "#{tag["name"]} (#{tag["count"]})" }
-    else
-      tags.map! { |tag| tag["name"] }
-    end
-
-    # Output the formatted tags
-    @util.output_tags(tags, { :format => options[:format] })
   end
 end
 
@@ -244,73 +189,61 @@ command :posts_tagged do |c|
   c.switch [:print0]
 
   c.action do |global_options, options, args|
-    # Convert the boolean operator to uppercase for consistency
     bool = options[:bool].upcase
-
-    # Initialize arrays to store files, tags, and matches
     files = []
     tags = []
     matches = []
-
-    # Separate files and tags from the arguments
     args.length.times do
       arg = args.pop
       if File.exist?(arg)
-        files.push(arg)  # Add existing files to the files array
+        files.push(arg)
       else
-        tags.push(arg)  # Add non-file arguments to the tags array
+        tags.push(arg)
       end
     end
 
-    # If piped content is provided and it is a list of files, add them to the files array
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content
 
-    # If no files are provided, use the default post location
     if files.empty?
-      if @jt.default_post_location && File.exist?(@jt.default_post_location)
-        # Retrieves a list of files from the default post location with the specified post extension.
-        # The files are located using a glob pattern that matches all files with the given extension.
-        files = Dir.glob(File.join(@jt.default_post_location, "*.#{@jt.post_extension}"))
+      if @jt.default_post_location && File.exist?(File.dirname(@jt.default_post_location))
+        files = Dir.glob(@jt.default_post_location)
       end
     end
-
-    # Exit if no valid filenames are found in the arguments
-    raise NoValidFile if files.empty?
-
-    # Iterate over each file to find matches based on the boolean operator
-    files.each do |file|
+    exit_now! "No valid filename in arguments" if files.empty?
+    files.each { |file|
       if File.exist?(file)
-        post_tags = @jt.post_tags(file)  # Get tags for the current file
+        post_tags = @jt.post_tags(file)
 
         if bool == "AND"
-          # Check if all tags are present in the post tags
           matched = 0
-          tags.each { |tag| matched += 1 if post_tags.include?(tag) }
+          tags.each { |tag|
+            matched += 1 if post_tags.include?(tag)
+          }
           matches.push(file) if matched == tags.length
         elsif bool == "NOT"
-          # Check if none of the tags are present in the post tags
           matched = false
-          tags.each { |tag| matched = true if post_tags.include?(tag) }
+          tags.each { |tag|
+            matched = true if post_tags.include?(tag)
+          }
           matches.push(file) unless matched
         else
-          # Default to OR: Check if any of the tags are present in the post tags
-          tags.each { |tag| matches.push(file) unless matches.include?(file) if post_tags.include?(tag) }
+          tags.each { |tag|
+            if post_tags.include?(tag)
+              matches.push(file) unless matches.include?(file)
+            end
+          }
         end
       else
-        # Exit if the file is not found
-        raise FileNotFound, "File not found: #{file}"
+        raise "File not found: #{file}"
       end
-    end
+    }
 
-    # Create a search string from the tags and boolean operator
     search_string = tags.join(" #{bool} ")
-
-    # Output the results
     if matches.empty?
-      @util.console_log "No matching files found for #{search_string}"
+      console_log "No matching files found for #{search_string}"
     else
-      @util.console_log "(#{search_string})", { err: true }
-      @util.output_tags(matches, { format: options[:format], print0: options[:print0], grouping: "files" })
+      console_log "(#{search_string})", { :err => true }
+      output_tags(matches, { :format => options[:format], :print0 => options[:print0], :grouping => "files" })
     end
   end
 end
@@ -339,48 +272,15 @@ command :loners do |c|
   c.flag %i[e edit], :default_value => false, :type => String
 
   c.action do |global_options, options, args|
-    # Convert the max option to an integer
     max = options[:m].to_i
-
-    # Initialize arrays to store files and keywords
-    files = []
-    keywords = []
-
-    # Separate files and keywords from the arguments
-    args.length.times do
-      arg = args.pop
-      if File.exist?(arg)
-        files.push(arg)  # Add existing files to the files array
-      else
-        keywords.push(arg)  # Add non-file arguments to the keywords array
-      end
-    end
-
-    # If piped content is provided and it is a list of files, add them to the files array
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
-
-    # If no files are provided, use the default post location
-    if files.empty?
-      if @jt.default_post_location && File.exist?(@jt.default_post_location)
-        files = Dir.glob(File.join(@jt.default_post_location, "*.#{@jt.post_extension}"))
-      end
-    end
-
-    # Get tags with counts for the specified files
-    loner_tags = @jt.tags({ :counts => true, :files => files })
-
-    # Remove tags that are not loners (i.e., tags with counts greater than max)
+    loner_tags = @jt.get_tags({ :counts => true })
     loner_tags.delete_if { |tag|
       tag.class == FalseClass || tag["count"] > max
     }
-
-    # Sort loner tags by count
     loner_tags.sort_by! { |tag| tag["count"] }
 
-    # Exit if no tags matched the criteria
     exit_now! "No tags matched the criteria" if loner_tags.empty? || loner_tags.nil?
 
-    # If the edit option is provided, write the loner tags to a file for editing
     if options[:e]
       path = File.expand_path(options[:e])
       while File.exist?(path)
@@ -395,7 +295,7 @@ command :loners do |c|
       File.open(path, "w+") do |f|
         f.puts "# Edit this file to remove tags you want to keep,"
         f.puts "# then run `jtag remove -p '#{path}' [/path/to/posts/*.md]`"
-        f.puts "# to remove any tags left in this file."
+        f.puts "# to remove any tags left in the file."
         f.puts "#"
         f.puts "# The post counts are included for your convenience, and will"
         f.puts "# be automatically ignored when reading the list back in."
@@ -406,17 +306,15 @@ command :loners do |c|
         }
       end
 
-      @util.console_log "A list of results and instructions for use have been written to #{path}."
+      console_log "A list of results and instructions for use have been written to #{path}."
       if ENV["EDITOR"]
-        @util.console_log
+        console_log
         print "Would you like to open the file in #{ENV["EDITOR"]} now? (y/N) "
         input = STDIN.gets
         if input =~ /^y/i
           system "#{ENV["EDITOR"]} '#{path}'"
         end
       end
-
-      # If the remove option is provided, remove the loner tags from the specified files
     elsif options[:r]
       files = []
       args.length.times do
@@ -424,15 +322,14 @@ command :loners do |c|
         files.push(arg) if File.exist?(arg)
       end
 
-      files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+      files.concat(@piped_content.split("\n")) if @piped_content
 
       if files.empty?
-        if @jt.default_post_location && File.exist?(@jt.default_post_location)
-          files = Dir.glob(File.join(@jt.default_post_location, "*.#{@jt.post_extension}"))
+        if @jt.default_post_location && File.exist?(File.dirname(@jt.default_post_location))
+          files = Dir.glob(@jt.default_post_location)
         end
       end
       exit_now! "No valid filename in arguments" if files.empty?
-
       files.each { |file|
         tags = @jt.post_tags(file)
         loner_tags.each { |d|
@@ -446,17 +343,15 @@ command :loners do |c|
         }
         unless global_options[:t]
           @jt.update_file_tags(file, tags)
-          @util.console_log "Updated tags for #{file}", :log => true, level: :warn
+          console_log "Updated tags for #{file}", :log => true
         end
 
-        @util.console_log level: :info
-        @util.console_log File.basename(file) + ":", level: :info
-        @util.output_tags(tags, :format => options[:format], :filename => file)
+        console_log
+        console_log File.basename(file) + ":"
+        output_tags(tags, :format => options[:format], :filename => file)
       }
-
-      # Otherwise, output the loner tags
     else
-      @util.output_tags(loner_tags.map { |tag|
+      output_tags(loner_tags.map { |tag|
         count = options[:no_counts] ? "" : " (#{tag["count"]})"
         "#{tag["name"]}#{count}"
       }, :format => options[:format])
@@ -481,24 +376,24 @@ command :tags do |c|
       end
     end
 
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content && @piped_content.file_list?
 
     tags = []
     files.each do |file|
       tags.concat(@jt.post_tags(file)) if File.exist?(file)
 
       if args.length > 0
-        @util.console_log level: :info
-        @util.console_log "STDIN:", level: :info
+        console_log
+        console_log "STDIN:"
       end
     end
 
     if tags.empty? || tags.nil?
-      @util.console_log "No tags in post", err: true, level: :info
+      console_log "No tags in post", { :err => true }
     else
       tags.sort!
       tags.uniq!
-      @util.output_tags(tags, { :format => options[:format] })
+      output_tags(tags, { :format => options[:format] })
     end
   end
 end
@@ -520,7 +415,7 @@ command :sort do |c|
       end
     end
 
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content
 
     files.each do |file|
       tags = @jt.post_tags(file)
@@ -529,13 +424,13 @@ command :sort do |c|
       unless global_options[:t]
         @jt.update_file_tags(file, tags)
       end
-      @util.console_log level: :info
-      @util.console_log "#{File.basename(file)}:", level: :info
+      console_log
+      console_log File.basename(file) + ":"
 
       if tags.empty? || tags.nil?
-        @util.console_log "No tags in post", err: true, level: :info
+        console_log "No tags in post", { :err => true }
       else
-        @util.output_tags(tags, { :format => options[:format], :filename => file })
+        output_tags(tags, { :format => options[:format], :filename => file })
       end
     end
   end
@@ -562,31 +457,31 @@ command :merge do |c|
       end
     end
 
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content
 
     if files.empty?
-      if @jt.default_post_location && File.exist?(@jt.default_post_location)
-        files = Dir.glob(File.join(@jt.default_post_location, "*.#{@jt.post_extension}"))
+      if @jt.default_post_location && File.exist?(File.dirname(@jt.default_post_location))
+        files = Dir.glob(@jt.default_post_location)
       end
     end
     exit_now! "No valid filename in arguments" if files.empty?
     exit_now! "Needs at least two tag inputs, one or more to merge, one to merge to" if tags.length < 2
     tags.reverse!
     merge_tag = tags.pop
-    @util.console_log %(Merging #{tags.join(", ")} to #{merge_tag}), level: :info
-    files.each do |file|
+    console_log %Q{Merging #{tags.join(", ")} to #{merge_tag}}
+    files.each { |file|
       new_tags = @jt.merge_tags(tags, merge_tag, file)
       next unless new_tags
-      unless global_options[:test]
+      unless global_options[:t]
         @jt.update_file_tags(file, new_tags)
-        @util.console_log level: :info
-        @util.console_log "Updated tags for #{file}", log: true, level: :warn
+        console_log
+        console_log "Updated tags for #{file}", :log => true
       end
 
-      @util.console_log level: :info
-      @util.console_log "#{File.basename(file)}:", level: :info
-      @util.output_tags(new_tags, { format: options[:format], filename: file })
-    end
+      console_log
+      console_log File.basename(file) + ":"
+      output_tags(new_tags, { :format => options[:format], :filename => file })
+    }
   end
 end
 
@@ -599,22 +494,22 @@ command :blacklist do |c|
   c.action do |global_options, options, args|
     if options[:r]
       @jt.unblacklist(args)
-      @util.console_log "Removed #{args.join(", ")} from blacklist.", level: :info, err: true
+      console_log "Removed #{args.join(", ")} from blacklist."
     else
       @jt.blacklist(args)
-      @util.console_log "Blacklisted #{args.join(", ")}.", level: :info, err: true
+      console_log "Blacklisted #{args.join(", ")}."
     end
   end
 end
 
 desc "Add tags to post(s)"
-arg_name "tags... file(s)", :multiple
+arg_name "tags", :multiple
+arg_name "file_pattern"
 command :add do |c|
-  c.desc "Format to use when outputting tags to console: list, json, plist, csv, yaml, or complete. Defaults to yaml."
-  c.long_desc "Use 'complete' to output full text when input is STDIN. First two letters of format are also accepted."
+  c.desc "Format to use when outputting tags to console: list, json, plist, csv or yaml. Defaults to yaml."
   c.arg_name "output_format"
   c.default_value "yaml"
-  c.flag %i[f format], :must_match => /^(csv?|l(?:i(?:st)?)?|y(?:a(?:ml)?)?|j(?:s(?:on)?)?|p(?:l(?:ist)?)?|co(?:mp(?:lete)?)?)$/, :type => String
+  c.flag %i[f format], :must_match => /^(csv|list|yaml|json|plist)$/, :type => String
 
   c.action do |global_options, options, args|
     files = []
@@ -628,40 +523,30 @@ command :add do |c|
       end
     end
 
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content
 
-    # if files.empty?
-    #   if @jt.default_post_location && File.exist?(@jt.default_post_location)
-    #     files = Dir.glob(File.join(@jt.default_post_location, "*.#{@jt.post_extension}"))
-    #   end
-    # end
-    # raise NoValidFile if files.empty?
-    raise NoTagsFound, "No tags to add specified" if new_tags.empty?
+    if files.empty?
+      if @jt.default_post_location && File.exist?(File.dirname(@jt.default_post_location))
+        files = Dir.glob(@jt.default_post_location)
+      end
+    end
+    exit_now! "No valid filename in arguments" if files.empty?
+    exit_now! "No tags found in arguments" if new_tags.empty?
 
-    if @piped_content && !@piped_content.file_list?(global_options[:null])
-      tags = @jt.post_tags(@piped_content, true)
+    files.each { |file|
+      tags = @jt.post_tags(file)
       tags.concat(new_tags)
-      tags.sort!
       tags.uniq!
-      @util.console_log "STDIN:", level: :debug
-      # TODO: Add debug level to console_log
-      @util.output_tags(tags, format: options[:format], content: @piped_content)
-    else
-      files.each do |file|
-        tags = @jt.post_tags(file)
-        tags.concat(new_tags)
-        tags.sort!
-        tags.uniq!
-        unless global_options[:t]
-          @jt.update_file_tags(file, tags)
-          @util.console_log "Updated tags for #{file}", log: true, level: :warn
-        end
-
-        @util.console_log level: :info
-        @util.console_log "#{File.basename(file)}:", level: :info
-        @util.output_tags(tags, :format => options[:format], :filename => file)
+      tags.sort!
+      unless global_options[:t]
+        @jt.update_file_tags(file, tags)
+        console_log "Updated tags for #{file}", :log => true
       end
-    end
+
+      console_log
+      console_log File.basename(file) + ":"
+      output_tags(tags, :format => options[:format], :filename => file)
+    }
   end
 end
 
@@ -690,11 +575,11 @@ command :remove do |c|
       end
     end
 
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content
 
     if files.empty?
-      if @jt.default_post_location && File.exist?(@jt.default_post_location)
-        files = Dir.glob(File.join(@jt.default_post_location, "*.#{@jt.post_extension}"))
+      if @jt.default_post_location && File.exist?(File.dirname(@jt.default_post_location))
+        files = Dir.glob(@jt.default_post_location)
       end
     end
     exit_now! "No valid filename in arguments" if files.empty?
@@ -708,10 +593,10 @@ command :remove do |c|
           remove_tags.push($1.strip)
         end
       }
-      @util.console_log "Found #{remove_tags.length} tags in #{File.basename(path)}...", level: :info, err: true
+      console_log "Found #{remove_tags.length} tags in #{File.basename(path)}..."
     end
 
-    raise NoTagsFound if remove_tags.empty?
+    exit_now! "No tags found in input, my work here is done" if remove_tags.empty?
 
     files.each { |file|
       tags = @jt.post_tags(file)
@@ -726,12 +611,12 @@ command :remove do |c|
       }
       unless global_options[:t]
         @jt.update_file_tags(file, tags)
-        @util.console_log "Updated tags for #{file}", log: true, level: :warn, err: true
+        console_log "Updated tags for #{file}", :log => true
       end
 
-      @util.console_log level: :info
-      @util.console_log "#{File.basename(file)}:", level: :info
-      @util.output_tags(tags, { :format => options[:format], :filename => file })
+      console_log
+      console_log File.basename(file) + ":"
+      output_tags(tags, { :format => options[:format], :filename => file })
     }
   end
 end
@@ -744,14 +629,17 @@ command :tag do |c|
   c.flag %i[f format], :must_match => /^(csv|list|yaml|json|plist|complete)$/, :type => String, :default_value => "yaml"
 
   c.action do |global_options, options, args|
-    if @piped_content && !@piped_content.file_list?(global_options[:null])
+    if @piped_content && !@piped_content.file_list?
       suggestions = @jt.suggest(@piped_content)
       if args.length > 0
-        @util.console_log level: :info
-        @util.console_log "STDIN:", level: info, err: true
+        console_log
+        console_log "STDIN:", :err => true
+      end
+      if options[:format] == "complete"
+        @jt.update_file_tags(@piped_content, suggestions, true)
+      else
+        output_tags(suggestions, :format => options[:format], :filename => nil)
       end
-
-      @util.output_tags(suggestions, :format => options[:format], :filename => nil)
     end
 
     files = []
@@ -760,7 +648,7 @@ command :tag do |c|
       files.push(arg) if File.exist?(arg)
     end
 
-    files.concat(@piped_content.split(global_options[:null] ? "\x00" : "\n")) if @piped_content && @piped_content.file_list?(global_options[:null])
+    files.concat(@piped_content.split("\n")) if @piped_content && @piped_content.file_list?
 
     files.each do |file|
       if File.exist?(File.expand_path(file))
@@ -769,37 +657,61 @@ command :tag do |c|
 
         unless global_options[:t]
           if @jt.update_file_tags(file, suggestions)
-            @util.console_log level: :info
-            @util.console_log "Updated file #{file} with:", log: true, level: :warn
+            console_log
+            console_log "Updated file #{file} with:", :log => true
           else
-            @util.console_log level: :info
-            @util.console_log "Failed to update #{file} with:", log: true, level: :error
+            console_log
+            console_log "Failed to update #{file} with:", :log => true
           end
         end
         if !global_options[:s] || global_options[:t]
           if args.length > 1
-            @util.console_log level: :info
-            @util.console_log "#{File.basename(file)}:", err: true, level: :info
+            console_log
+            console_log File.basename(file) + ":", :err => true, :log => true
           end
-          @util.output_tags(suggestions, :format => options[:format], :filename => file)
+          output_tags(suggestions, :format => options[:format], :filename => file)
         end
         suggestions = nil
       else
-        raise FileNotFound, "No such file: #{file}"
+        raise "No such file: #{file}"
       end
     end
   end
 end
 
-##
-## Move deprecated config files to new location
-##
-## @return [void]
-##
-def update_deprecated_config
-  if File.exist?(File.expand_path("~/.jtag"))
-    FileUtils.mv(File.expand_path("~/.jtag"), File.expand_path("~/.config/jtag"))
-    @util.console_log "Moved ~/.jtag to ~/.config/jtag", level: :info, err: true, log: false
+def output_tags(tags, options)
+  format = options[:format] || "yaml"
+  print0 = options[:print0] || false
+  filename = options[:filename] || false
+  case format
+  when "list"
+    unless print0
+      console_log tags.join("\n")
+    else
+      console_log tags.map { |tag|
+        if tag.strip =~ /\b\s\b/
+          %Q{"#{tag.strip}"}
+        else
+          tag.strip
+        end
+      }.join(" ")
+    end
+  when "csv"
+    console_log tags.to_csv
+  when "json"
+    out = {}
+    out["tags"] = tags
+    out["path"] = filename if filename
+    console_log out.to_json
+  when "plist"
+    out = {}
+    out["path"] = filename if filename
+    console_log tags.to_plist
+  else
+    out = {}
+    options[:grouping] ||= "tags"
+    out[options[:grouping]] = tags
+    console_log out.to_yaml
   end
 end
 
@@ -814,43 +726,33 @@ end
 # end
 
 pre do |global, command, options, args|
-  Signal.trap("PIPE", "EXIT")
-
-  @util = JekyllTag::Util.new
-  @util.config_target = if global[:config_dir]
-      File.expand_path(global[:config_dir])
-    else
-      File.expand_path("~/.config/jtag")
-    end
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  @silent = global[:silent]
 
-  # if global[:debug] == 0 or global[:silent], run silently
-  @util.silent = global[:debug] == 0 || global[:silent]
+  Signal.trap("PIPE", "EXIT")
 
-  # set up logging
-  logfile = File.open(File.join(Dir.tmpdir, "jtag_actions.log"), "a")
+  @logfile = File.open(File.join(Dir.tmpdir, "jtag_actions.log"), "a")
 
-  # set up logger
-  @util.log = Logger.new(logfile, shift_age = 7, shift_size = 1048576)
+  @log = Logger.new(@logfile, shift_age = 7, shift_size = 1048576)
 
-  # set log level based on flags
-  @util.debug_level = @silent ? 0 : global[:debug]
+  # Check for old config directory and migrate if needed
+  migrate_old_config
 
-  # check for config files, write them if they don't exist
-  unless @util.config_files_complete?
-    @util.write_config
-    @util.console_log "Missing config files written to #{@util.config_target}. Please check your configuration.", err: true, level: :error
+  unless config_files_complete?
+    write_config
+    console_log "Missing config files written to #{@config_target}. Please check your configuration.", { :err => true }
     return false
   end
 
-  configfile = File.join(@util.config_target, "config.yml")
+  configfile = File.expand_path("~/.config/jtag/config.yml")
 
-  # load config file
-  config = YAML.load_file(configfile)
-  global[:config] = config.symbolize_keys
+  global[:config] = YAML::load(File.open(configfile, "r"))
+  global[:support] = File.expand_path("~/.config/jtag")
 
   @piped_content = $stdin.read if $stdin.fcntl(Fcntl::F_GETFL, 0) == 0 || $stdin.stat.pipe?
 
-  @jt = JekyllTag::JTag.new(@util.config_target, global[:config])
+  @jt = JTag.new(global[:support], global[:config])
 
   true
 end
@@ -862,11 +764,7 @@ post do |global, command, options, args|
 end
 
 on_error do |exception|
-  if exception.is_a?(NoValidFile) || exception.is_a?(FileNotFound) || exception.is_a?(NoTagsFound)
-    @util.console_log "#{@jt.color(:red)}#{exception.message}", err: true, level: :error
-    return false
-  end
-
+  # Error logic here
   # return false to skip default error handling
   true
 end