uniword 1.0.0 → 1.0.3

data/lib/uniword/cli.rb

@@ -1,737 +1,20 @@
 # frozen_string_literal: true
 
-require 'thor'
-
-# All classes are autoloaded via lib/uniword.rb
-# No require_relative needed - autoload handles lazy loading
-
-module Uniword
-  # StyleSet subcommands for Uniword CLI
-  class StyleSetCLI < Thor
-    # Error handling for all commands
-    def self.exit_on_failure?
-      true
-    end
-
-    desc 'list', 'List all available bundled StyleSets'
-    long_desc <<~DESC
-      Display all StyleSets that are bundled with uniword.
-
-      These StyleSets can be loaded using StyleSet.load(name) or doc.apply_styleset(name).
-
-      Examples:
-        $ uniword styleset list
-        $ uniword styleset list --verbose
-    DESC
-    option :verbose, aliases: '-v', desc: 'Show detailed information', type: :boolean,
-                     default: false
-    def list
-      stylesets = StyleSet.available_stylesets
-
-      if stylesets.empty?
-        say 'No bundled StyleSets found.', :yellow
-        say "Run 'uniword styleset import' to import .dotx StyleSets.", :yellow
-        return
-      end
-
-      say "Available StyleSets (#{stylesets.count}):", :green
-      stylesets.each do |styleset_name|
-        if options[:verbose]
-          # Load StyleSet to show details
-          begin
-            styleset = StyleSet.load(styleset_name)
-            say "  #{styleset_name}:", :cyan
-            say "    Name: #{styleset.name}"
-            say "    Styles: #{styleset.styles.count}"
-            say "    Paragraph styles: #{styleset.paragraph_styles.count}"
-            say "    Character styles: #{styleset.character_styles.count}"
-            say "    Table styles: #{styleset.table_styles.count}"
-          rescue StandardError => e
-            say "  #{styleset_name}: Error loading - #{e.message}", :red
-          end
-        else
-          say "  - #{styleset_name}"
-        end
-      end
-    end
-
-    desc 'import', 'Import .dotx files to YAML StyleSet library'
-    long_desc <<~DESC
-      Import .dotx StyleSet files to YAML format for bundling with gem.
-
-      The YAML format is human-readable, faster to load, and easier to customize.
-
-      Examples:
-        $ uniword styleset import
-        $ uniword styleset import --source stylesets/ --output data/stylesets
-    DESC
-    option :source, type: :string, default: 'references/word-package/style-sets',
-                    desc: 'Source directory with .dotx files'
-    option :output, type: :string, default: 'data/stylesets',
-                    desc: 'Output directory for YAML files'
-    option :verbose, aliases: '-v', desc: 'Verbose output', type: :boolean, default: false
-    def import
-      say "Importing StyleSets from #{options[:source]}...", :green if options[:verbose]
-
-      importer = Stylesets::StyleSetImporter.new
-      count = importer.import_all(options[:source], options[:output])
-
-      say "Successfully imported #{count} StyleSets to #{options[:output]}/", :green
-
-      if options[:verbose]
-        stylesets = Dir.glob(File.join(options[:output], '*.yml')).map do |f|
-          File.basename(f, '.yml')
-        end.sort
-        say "\nAvailable StyleSets:", :cyan
-        stylesets.each { |name| say "  - #{name}" }
-      end
-    rescue StandardError => e
-      say "Error importing StyleSets: #{e.message}", :red
-      exit 1
-    end
-
-    desc 'apply INPUT OUTPUT', 'Apply a StyleSet to a document'
-    long_desc <<~DESC
-      Apply a StyleSet to an existing document.
-
-      You can apply either:
-      - A bundled StyleSet by name (e.g., 'distinctive', 'basic')
-      - A .dotx StyleSet file by path
-
-      StyleSets contain collections of paragraph, character, and table styles
-      that provide consistent formatting for documents.
-
-      Examples:
-        $ uniword styleset apply input.docx output.docx --name distinctive
-        $ uniword styleset apply input.docx output.docx --name distinctive --verbose
-        $ uniword styleset apply input.docx output.docx --file Distinctive.dotx
-    DESC
-    option :name, type: :string,
-                  desc: 'Bundled StyleSet name (e.g., distinctive, basic)'
-    option :file, type: :string,
-                  desc: 'Path to .dotx StyleSet file'
-    option :strategy, type: :string, default: 'keep_existing',
-                      desc: 'Application strategy (keep_existing, replace, rename)'
-    option :verbose, aliases: '-v', desc: 'Verbose output', type: :boolean, default: false
-    def apply(input_path, output_path)
-      # Validate that either --name or --file is provided
-      unless options[:name] || options[:file]
-        say '✗ Error: Must specify either --name for bundled StyleSet or --file for .dotx file',
-            :red
-        exit 1
-      end
-
-      if options[:name] && options[:file]
-        say '✗ Error: Cannot specify both --name and --file', :red
-        exit 1
-      end
-
-      say "Loading document #{input_path}...", :green if options[:verbose]
-
-      # Load input document
-      doc = DocumentFactory.from_file(input_path)
-
-      if options[:verbose]
-        say '  Loaded document:', :cyan
-        say "    Paragraphs: #{doc.paragraphs.count}"
-        say "    Current styles: #{doc.styles.count}"
-      end
-
-      # Apply StyleSet
-      begin
-        if options[:name]
-          # Apply bundled StyleSet
-          say "Applying bundled StyleSet '#{options[:name]}'...", :green if options[:verbose]
-          strategy = options[:strategy].to_sym
-          doc.apply_styleset(options[:name], strategy: strategy)
-        else
-          # Apply .dotx file
-          unless File.exist?(options[:file])
-            say "✗ StyleSet file not found: #{options[:file]}", :red
-            exit 1
-          end
-          say "Applying StyleSet from #{options[:file]}...", :green if options[:verbose]
-          styleset = StyleSet.from_dotx(options[:file])
-          strategy = options[:strategy].to_sym
-          styleset.apply_to(doc, strategy: strategy)
-        end
-
-        if options[:verbose]
-          say '  Applied StyleSet:', :cyan
-          say "    Total styles: #{doc.styles.count}"
-          say "    Strategy: #{options[:strategy]}"
-        end
-      rescue ArgumentError => e
-        say "✗ Error applying StyleSet: #{e.message}", :red
-        exit 1
-      end
-
-      # Save output document
-      doc.save(output_path)
-
-      say "StyleSet applied successfully to #{output_path}", :green
-    rescue Uniword::Error => e
-      say "Error: #{e.message}", :red
-      exit 1
-    rescue StandardError => e
-      say "Unexpected error: #{e.message}", :red
-      say e.backtrace.join("\n"), :red if options[:verbose]
-      exit 1
-    end
-  end
-
-  # Word Resources subcommands for Uniword CLI
-  class ResourcesCLI < Thor
-    def self.exit_on_failure?
-      true
-    end
-
-    desc 'export OUTPUT_DIR', 'Export Word resources from local Microsoft Word installation'
-    long_desc <<~DESC
-      Export raw Word resources (.thmx themes, .dotx stylesets) from the
-      local Microsoft Word installation to a target directory.
-
-      This copies the native files without conversion to YAML.
-
-      The --word-app option specifies the path to Microsoft Word.app.
-      On macOS, this is typically /Applications/Microsoft Word.app
-
-      Examples:
-        $ uniword resources export uniword-private/word-resources --word-app "/Applications/Microsoft Word.app"
-        $ uniword resources export /path/to/output --word-app "/Applications/Microsoft Word.app"
-    DESC
-    option :verbose, aliases: '-v', desc: 'Verbose output', type: :boolean, default: false
-    option :word_app, aliases: '-w', desc: 'Path to Microsoft Word.app', type: :string,
-                      required: true, banner: 'PATH'
-    def export(output_dir)
-      word_app_path = options[:word_app]
-
-      unless word_app_path
-        say '--word-app is required', :red
-        exit 1
-      end
-
-      unless File.exist?(word_app_path)
-        say "Microsoft Word not found at: #{word_app_path}", :red
-        exit 1
-      end
-
-      unless File.directory?(word_app_path)
-        say "#{word_app_path} is not a directory (expected path to Microsoft Word.app)", :red
-        exit 1
-      end
-
-      resources_path = File.join(word_app_path, 'Contents', 'Resources')
-
-      output_base = output_dir || 'uniword-private/word-resources'
-
-      # Export themes from Word's Office Themes/ to office-themes/
-      themes_path = File.join(resources_path, 'Office Themes')
-      if Dir.exist?(themes_path)
-        themes_dir = File.join(output_base, 'office-themes')
-        FileUtils.mkdir_p(themes_dir)
-        count = 0
-        Dir.glob("#{themes_path}/*.thmx").each do |thmx|
-          FileUtils.cp(thmx, themes_dir)
-          say "  Copied #{File.basename(thmx)}" if options[:verbose]
-          count += 1
-        end
-        say "Exported #{count} themes to #{themes_dir}", :green
-      else
-        say 'No themes found in Word installation', :yellow
-      end
-
-      # Export QuickStyles from Word's QuickStyles/ to quick-styles/
-      stylesets_path = File.join(resources_path, 'QuickStyles')
-      if Dir.exist?(stylesets_path)
-        styles_dir = File.join(output_base, 'quick-styles')
-        FileUtils.mkdir_p(styles_dir)
-        count = 0
-        Dir.glob("#{stylesets_path}/*.dotx").each do |dotx|
-          FileUtils.cp(dotx, styles_dir)
-          say "  Copied #{File.basename(dotx)}" if options[:verbose]
-          count += 1
-        end
-        say "Exported #{count} stylesets to #{styles_dir}", :green
-      else
-        say 'No QuickStyles found in Word installation', :yellow
-      end
-
-      # Export Document Elements from all *.lproj/Document Elements/ to document-elements/
-      lproj_count = 0
-      elements_count = 0
-      elements_dir = File.join(output_base, 'document-elements')
-      Dir.glob("#{resources_path}/*.lproj").each do |lproj|
-        doc_elements_path = File.join(lproj, 'Document Elements')
-        next unless Dir.exist?(doc_elements_path)
-
-        lproj_name = File.basename(lproj, '.lproj')
-        lproj_elements_dir = File.join(elements_dir, lproj_name)
-        FileUtils.mkdir_p(lproj_elements_dir)
-        Dir.glob("#{doc_elements_path}/*.dotx").each do |dotx|
-          FileUtils.cp(dotx, lproj_elements_dir)
-          say "  #{lproj_name}: #{File.basename(dotx)}" if options[:verbose]
-          elements_count += 1
-        end
-        lproj_count += 1
-      end
-      if elements_count.positive?
-        say "Exported #{elements_count} document elements from #{lproj_count} languages to #{elements_dir}",
-            :green
-      else
-        say 'No Document Elements found in Word installation', :yellow
-      end
-
-      # Export Citation Styles from Word's Style/ to citation-styles/
-      citation_styles_path = File.join(resources_path, 'Style')
-      if Dir.exist?(citation_styles_path)
-        styles_dir = File.join(output_base, 'citation-styles')
-        FileUtils.mkdir_p(styles_dir)
-        count = 0
-        Dir.glob("#{citation_styles_path}/*.xsl").each do |xsl|
-          FileUtils.cp(xsl, styles_dir)
-          say "  Copied #{File.basename(xsl)}" if options[:verbose]
-          count += 1
-        end
-        say "Exported #{count} citation styles to #{styles_dir}", :green
-      else
-        say 'No citation styles found in Word installation', :yellow
-      end
-
-      # Export Theme Colors from Word's Office Themes/Theme Colors/ to theme-colors/
-      theme_colors_path = File.join(resources_path, 'Office Themes', 'Theme Colors')
-      if Dir.exist?(theme_colors_path)
-        colors_dir = File.join(output_base, 'theme-colors')
-        FileUtils.mkdir_p(colors_dir)
-        count = 0
-        Dir.glob("#{theme_colors_path}/*.xml").each do |xml|
-          FileUtils.cp(xml, colors_dir)
-          say "  Copied #{File.basename(xml)}" if options[:verbose]
-          count += 1
-        end
-        say "Exported #{count} theme colors to #{colors_dir}", :green
-      else
-        say 'No theme colors found in Word installation', :yellow
-      end
-
-      # Export Theme Fonts from Word's Office Themes/Theme Fonts/ to theme-fonts/
-      theme_fonts_path = File.join(resources_path, 'Office Themes', 'Theme Fonts')
-      if Dir.exist?(theme_fonts_path)
-        fonts_dir = File.join(output_base, 'theme-fonts')
-        FileUtils.mkdir_p(fonts_dir)
-        count = 0
-        Dir.glob("#{theme_fonts_path}/*.xml").each do |xml|
-          FileUtils.cp(xml, fonts_dir)
-          say "  Copied #{File.basename(xml)}" if options[:verbose]
-          count += 1
-        end
-        say "Exported #{count} theme fonts to #{fonts_dir}", :green
-      else
-        say 'No theme fonts found in Word installation', :yellow
-      end
-
-      say "\nWord resources exported to #{output_base}", :green
-    rescue StandardError => e
-      say "Error: #{e.message}", :red
-      exit 1
-    end
-  end
-
-  # Theme subcommands for Uniword CLI
-  class ThemeCLI < Thor
-    # Error handling for all commands
-    def self.exit_on_failure?
-      true
-    end
-
-    desc 'list', 'List all available bundled themes'
-    long_desc <<~DESC
-      Display all themes that are bundled with uniword.
-
-      These themes can be loaded using Themes::Theme.load(name) and
-      converted using Themes::ThemeTransformation.
-
-      Examples:
-        $ uniword theme list
-        $ uniword theme list --verbose
-    DESC
-    option :verbose, aliases: '-v', desc: 'Show detailed information', type: :boolean,
-                     default: false
-    def list
-      themes = Themes::Theme.available_themes
-
-      if themes.empty?
-        say 'No bundled themes found.', :yellow
-        say "Run 'uniword theme import' to import Office themes.", :yellow
-        return
-      end
-
-      say "Available themes (#{themes.count}):", :green
-      themes.each do |theme_name|
-        if options[:verbose]
-          # Load theme to show details
-          begin
-            friendly = Themes::Theme.load(theme_name)
-            say "  #{theme_name}:", :cyan
-            say "    Name: #{friendly.name}"
-            say "    Colors: #{friendly.color_scheme&.colors&.count || 0}"
-            say "    Variants: #{friendly.variants&.count || 0}"
-          rescue StandardError => e
-            say "  #{theme_name}: Error loading - #{e.message}", :red
-          end
-        else
-          say "  - #{theme_name}"
-        end
-      end
-    end
-
-    desc 'import', 'Import .thmx files to YAML theme library'
-    long_desc <<~DESC
-      Import Office theme (.thmx) files to YAML format for bundling with gem.
-
-      The YAML format is human-readable, faster to load, and easier to customize.
-
-      Examples:
-        $ uniword theme import
-        $ uniword theme import --source themes/ --output data/themes
-    DESC
-    option :source, type: :string, default: 'references/word-package/office-themes',
-                    desc: 'Source directory with .thmx files'
-    option :output, type: :string, default: 'data/themes',
-                    desc: 'Output directory for YAML files'
-    option :verbose, aliases: '-v', desc: 'Verbose output', type: :boolean, default: false
-    def import
-      say "Importing themes from #{options[:source]}...", :green if options[:verbose]
-
-      importer = Themes::ThemeImporter.new
-      count = importer.import_all(options[:source], options[:output])
-
-      say "Successfully imported #{count} themes to #{options[:output]}/", :green
-
-      if options[:verbose]
-        themes = Dir.glob(File.join(options[:output], '*.yml')).map do |f|
-          File.basename(f, '.yml')
-        end.sort
-        say "\nAvailable themes:", :cyan
-        themes.each { |name| say "  - #{name}" }
-      end
-    rescue StandardError => e
-      say "Error importing themes: #{e.message}", :red
-      exit 1
-    end
-
-    desc 'apply INPUT OUTPUT', 'Apply a theme to a document'
-    long_desc <<~DESC
-      Apply a theme to an existing document.
-
-      You can apply either:
-      - A bundled theme by name (e.g., 'atlas', 'office_theme')
-      - A .thmx theme file by path
-
-      Themes control the document's colors, fonts, and visual styling.
-      You can optionally apply a specific theme variant for different
-      visual styles.
-
-      Examples:
-        $ uniword theme apply input.docx output.docx --name atlas
-        $ uniword theme apply input.docx output.docx --name atlas --variant 2
-        $ uniword theme apply input.docx output.docx --file Atlas.thmx
-        $ uniword theme apply input.docx output.docx --file themes/Office.thmx --variant 2
-    DESC
-    option :name, type: :string,
-                  desc: 'Bundled theme name (e.g., atlas, office_theme)'
-    option :file, type: :string,
-                  desc: 'Path to .thmx theme file'
-    option :variant, type: :string,
-                     desc: 'Theme variant (variant1, variant2, etc. or numeric 1, 2, etc.)'
-    option :verbose, aliases: '-v', desc: 'Verbose output', type: :boolean, default: false
-    def apply(input_path, output_path)
-      # Validate that either --name or --file is provided
-      unless options[:name] || options[:file]
-        say '✗ Error: Must specify either --name for bundled theme or --file for .thmx file', :red
-        exit 1
-      end
-
-      if options[:name] && options[:file]
-        say '✗ Error: Cannot specify both --name and --file', :red
-        exit 1
-      end
-
-      say "Loading document #{input_path}...", :green if options[:verbose]
-
-      # Load input document
-      doc = DocumentFactory.from_file(input_path)
-
-      if options[:verbose]
-        say '  Loaded document:', :cyan
-        say "    Paragraphs: #{doc.paragraphs.count}"
-        say "    Current theme: #{doc.theme&.name || 'None'}"
-      end
-
-      # Apply theme
-      begin
-        if options[:name]
-          # Apply bundled theme
-          say "Applying bundled theme '#{options[:name]}'...", :green if options[:verbose]
-          doc.apply_theme(options[:name], variant: options[:variant])
-        else
-          # Apply .thmx file
-          unless File.exist?(options[:file])
-            say "✗ Theme file not found: #{options[:file]}", :red
-            exit 1
-          end
-          say "Applying theme from #{options[:file]}...", :green if options[:verbose]
-          doc.apply_theme_file(options[:file], variant: options[:variant])
-        end
-
-        if options[:verbose]
-          say '  Applied theme:', :cyan
-          say "    Theme name: #{doc.theme.name}"
-          say "    Colors: #{doc.theme.color_scheme.colors.keys.join(', ')}"
-          say "    Major font: #{doc.theme.major_font}"
-          say "    Minor font: #{doc.theme.minor_font}"
-          if doc.theme.variants.any?
-            say "    Available variants: #{doc.theme.variants.keys.join(', ')}"
-          end
-        end
-      rescue ArgumentError => e
-        say "✗ Error applying theme: #{e.message}", :red
-        exit 1
-      end
-
-      # Save output document
-      doc.save(output_path)
-
-      say "Theme applied successfully to #{output_path}", :green
-    rescue Uniword::Error => e
-      say "Error: #{e.message}", :red
-      exit 1
-    rescue StandardError => e
-      say "Unexpected error: #{e.message}", :red
-      say e.backtrace.join("\n"), :red if options[:verbose]
-      exit 1
-    end
-  end
-
-  # Command-line interface for Uniword
-  #
-  # Provides commands for document conversion, inspection, and validation
-  class CLI < Thor
-    # Error handling for all commands
-    def self.exit_on_failure?
-      true
-    end
-
-    desc 'convert INPUT OUTPUT', 'Convert document between formats'
-    long_desc <<~DESC
-      Convert a document from one format to another.
-
-      Supports automatic format detection based on file extensions,
-      or you can specify formats explicitly with --from and --to options.
-
-      Supported formats: DOCX, MHTML
-
-      Examples:
-        $ uniword convert input.docx output.mhtml
-        $ uniword convert input.mhtml output.docx --verbose
-        $ uniword convert input.doc output.docx --from doc --to docx
-    DESC
-    option :from, aliases: '-f', desc: 'Input format (docx/mhtml)', type: :string
-    option :to, aliases: '-t', desc: 'Output format (docx/mhtml)', type: :string
-    option :verbose, aliases: '-v', desc: 'Verbose output', type: :boolean, default: false
-    def convert(input_path, output_path)
-      from_format = options[:from]&.to_sym || :auto
-      to_format = options[:to]&.to_sym || :auto
-
-      say "Converting #{input_path} to #{output_path}...", :green if options[:verbose]
-
-      # Load document
-      doc = DocumentFactory.from_file(input_path, format: from_format)
-
-      if options[:verbose]
-        say '  Loaded document:', :cyan
-        say "    Paragraphs: #{doc.paragraphs.count}"
-        say "    Tables: #{doc.tables.count}"
-        say "    Styles: #{doc.styles_configuration&.styles&.count || 0}"
-      end
-
-      # Save document
-      doc.save(output_path, format: to_format)
-
-      say 'Conversion complete!', :green if options[:verbose]
-    rescue Uniword::Error => e
-      say "Error: #{e.message}", :red
-      exit 1
-    rescue StandardError => e
-      say "Unexpected error: #{e.message}", :red
-      say e.backtrace.join("\n"), :red if options[:verbose]
-      exit 1
-    end
-
-    desc 'info FILE', 'Display document information'
-    long_desc <<~DESC
-      Display detailed information about a document including:
-      - Detected format
-      - Number of paragraphs and tables
-      - Text content length
-      - Styles used
-      - Document structure
-
-      Examples:
-        $ uniword info document.docx
-        $ uniword info report.mhtml --verbose
-    DESC
-    option :verbose, aliases: '-v', desc: 'Show detailed information', type: :boolean,
-                     default: false
-    def info(path)
-      say "Analyzing #{path}...", :green
-
-      # Detect format
-      detector = ::Uniword::FormatDetector.new
-      format = detector.detect(path)
-      say "\nFormat: #{format.to_s.upcase}", :cyan
-
-      # Load document
-      doc = DocumentFactory.from_file(path)
-
-      # Basic statistics
-      say "\nDocument Statistics:", :cyan
-      say "  Paragraphs: #{doc.paragraphs.count}"
-      say "  Tables: #{doc.tables.count}"
-      say "  Text length: #{doc.text.length} characters"
-
-      # Styles information
-      if doc.styles_configuration&.styles&.any?
-        say "  Styles: #{doc.styles_configuration.styles.count}"
-      end
-
-      # Detailed information
-      if options[:verbose]
-        say "\nDetailed Information:", :cyan
-
-        # Show first few paragraphs
-        if doc.paragraphs.any?
-          say '  First paragraphs:'
-          doc.paragraphs.first(3).each_with_index do |para, i|
-            text = para.text[0..80]
-            text += '...' if para.text.length > 80
-            say "    #{i + 1}. #{text}"
-          end
-        end
-
-        # Show tables
-        if doc.tables.any?
-          say '  Tables:'
-          doc.tables.each_with_index do |table, i|
-            say "    #{i + 1}. #{table.row_count} rows × #{table.column_count} columns"
-          end
-        end
-      end
-
-      say "\nAnalysis complete!", :green
-    rescue Uniword::Error => e
-      say "Error: #{e.message}", :red
-      exit 1
-    rescue StandardError => e
-      say "Unexpected error: #{e.message}", :red
-      exit 1
-    end
-
-    desc 'validate FILE', 'Validate document structure'
-    long_desc <<~DESC
-      Validate a document's structure and check for common issues.
-
-      Checks include:
-      - File format integrity
-      - Document structure validity
-      - Element validation
-      - Content completeness
-
-      Examples:
-        $ uniword validate document.docx
-        $ uniword validate report.mhtml --verbose
-    DESC
-    option :verbose, aliases: '-v', desc: 'Show detailed validation results', type: :boolean,
-                     default: false
-    def validate(path)
-      say "Validating #{path}...", :green
-
-      # Check file exists
-      unless File.exist?(path)
-        say "✗ File not found: #{path}", :red
-        exit 1
-      end
-
-      # Try to load document
-      begin
-        doc = DocumentFactory.from_file(path)
-        say '✓ File format is valid', :green
-      rescue Uniword::CorruptedFileError => e
-        say "✗ File is corrupted: #{e.reason}", :red
-        exit 1
-      rescue Uniword::Error => e
-        say "✗ Validation failed: #{e.message}", :red
-        exit 1
-      end
-
-      # Validate document structure
-      if doc.valid?
-        say '✓ Document structure is valid', :green
-      else
-        say '✗ Document has structural issues', :yellow
-      end
-
-      # Check for content
-      if doc.paragraphs.any? || doc.tables.any?
-        say '✓ Document contains content', :green
-      else
-        say '⚠ Document appears to be empty', :yellow
-      end
-
-      # Detailed validation
-      if options[:verbose]
-        say "\nDetailed Validation:", :cyan
-
-        # Check paragraphs
-        empty_paras = doc.paragraphs.count(&:empty?)
-        if empty_paras.positive?
-          say "  ⚠ #{empty_paras} empty paragraph(s) found", :yellow
-        else
-          say '  ✓ All paragraphs have content', :green
-        end
-
-        # Check tables
-        if doc.tables.any?
-          empty_tables = doc.tables.count(&:empty?)
-          if empty_tables.positive?
-            say "  ⚠ #{empty_tables} empty table(s) found", :yellow
-          else
-            say '  ✓ All tables have content', :green
-          end
-        end
-      end
-
-      say "\nValidation complete!", :green
-    rescue StandardError => e
-      say "Unexpected error during validation: #{e.message}", :red
-      exit 1
-    end
-
-    # Register theme subcommand
-    desc 'theme SUBCOMMAND', 'Manage document themes'
-    subcommand 'theme', ThemeCLI
-
-    # Register styleset subcommand
-    desc 'styleset SUBCOMMAND', 'Manage document StyleSets'
-    subcommand 'styleset', StyleSetCLI
-
-    # Register resources subcommand
-    desc 'resources SUBCOMMAND', 'Manage Word resources (themes, stylesets, document elements)'
-    subcommand 'resources', ResourcesCLI
-
-    desc 'version', 'Show Uniword version'
-    def version
-      say "Uniword version #{Uniword::VERSION}", :green
-    end
-  end
-end
+# CLI entry point — loads decomposed classes from lib/uniword/cli/.
+# Uniword::CLI is the main Thor class. Subcommands are in separate files.
+
+require_relative "cli/helpers"
+require_relative "cli/styleset_cli"
+require_relative "cli/resources_cli"
+require_relative "cli/theme_cli"
+require_relative "cli/generate_cli"
+require_relative "cli/review_cli"
+require_relative "cli/diff_cli"
+require_relative "cli/toc_cli"
+require_relative "cli/images_cli"
+require_relative "cli/spellcheck_cli"
+require_relative "cli/template_cli"
+require_relative "cli/headers_cli"
+require_relative "cli/watermark_cli"
+require_relative "cli/protect_cli"
+require_relative "cli/main"