rosett-ai 1.3.3

data/lib/rosett_ai/thor/tasks/backup.rb

@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'thor'
+require 'terminal-table'
+require 'rainbow'
+require 'tty-spinner'
+require 'fileutils'
+require 'digest'
+require 'tempfile'
+require_relative '../../formatting'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for backing up rosett-ai directory structure and assets
+      class Backup < ::Thor
+        include RosettAi::Formatting
+
+        default_task :create
+
+        desc 'create', 'Back up rosett-ai directory structure and assets'
+        long_desc <<~LONGDESC
+          Creates a compressed archive of rai configuration, rules, and documentation.
+          Requires at least one of --global or --local to specify backup scope.
+
+          Flags:
+            --global: Back up ~/.claude/ structure
+            --local: Back up project .claude/ and CLAUDE.md
+            --compression: Algorithm (zip, tar.gz, tar.xz)
+            --compression-ratio: Compression level 0-9
+            --destination: Custom output path or URI
+
+          EXAMPLES
+
+            raictl backup --global
+            raictl backup --global --local
+            raictl backup --global --compression tar.gz --compression-ratio 9
+            raictl backup --local --destination file:///tmp/backup.zip
+
+          Related commands: raictl init, rai compile
+        LONGDESC
+        method_option :global,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Back up global ~/.claude/ structure'
+        method_option :local,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Back up project-local .claude/ and CLAUDE.md'
+        method_option :compression,
+                      type: :string,
+                      default: 'zip',
+                      desc: 'Compression algorithm: zip, tar.gz, tar.xz'
+        method_option :compression_ratio,
+                      type: :numeric,
+                      default: nil,
+                      desc: 'Compression level (0-9, if supported)'
+        method_option :destination,
+                      type: :string,
+                      default: nil,
+                      desc: 'Output path or URI (default: nncc_backup_<date>.<ext>)'
+        method_option :output,
+                      type: :string,
+                      default: nil,
+                      desc: 'Output file path (shorthand for --destination)'
+
+        def create
+          validate_options!
+          compressor = resolve_compressor
+          check_compression_available!(compressor)
+          destination = resolve_destination(compressor)
+          files = collect_all_files
+
+          if files.empty?
+            puts Rainbow(t('no_files')).yellow
+            return
+          end
+
+          result = create_archive(files, compressor, destination)
+          print_summary(result)
+        end
+
+        desc 'restore PATH', 'Restore rosett-ai configuration from a backup archive'
+        long_desc <<~LONGDESC
+          Restores rai configuration from a previously created backup archive.
+          Supports .zip, .tar.gz, and .tar.xz archives.
+
+          Archives contain global/ and/or local/ prefixed entries which are
+          restored to their respective directories.
+
+          EXAMPLES
+
+            raictl backup restore ~/.config/rosett-ai/backups/rai_backup_2026-04-18.tar.gz
+            raictl backup restore /path/to/backup.zip
+        LONGDESC
+        method_option :global,
+                      type: :boolean,
+                      default: true,
+                      desc: 'Restore global scope entries'
+        method_option :local,
+                      type: :boolean,
+                      default: true,
+                      desc: 'Restore local scope entries'
+
+        def restore(archive_path)
+          validate_archive!(archive_path)
+          entries = extract_entries(archive_path)
+          restored = restore_entries(entries)
+          print_restore_summary(archive_path, restored)
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.backup.#{key}", **)
+        end
+
+        def validate_options!
+          return if options[:global] || options[:local]
+
+          raise ::Thor::Error, t('no_scope')
+        end
+
+        def resolve_compressor
+          RosettAi::Backup::Compressor.for(options[:compression])
+        end
+
+        def check_compression_available!(compressor)
+          return if compressor.available?
+
+          raise RosettAi::BackupError,
+                t('compression_unavailable', type: options[:compression])
+        end
+
+        def resolve_destination(compressor)
+          dest_string = options[:output] || options[:destination] || default_destination(compressor)
+          RosettAi::Backup::Destination.for(dest_string)
+        end
+
+        def default_destination(compressor)
+          backup_dir = RosettAi.paths.rai_config_dir.join('backups')
+          backup_dir.join("rai_backup_#{Date.today}#{compressor.extension}").to_s
+        end
+
+        def collect_all_files
+          files = []
+          files.concat(collect_global_files) if options[:global]
+          files.concat(collect_local_files) if options[:local]
+          files
+        end
+
+        def collect_global_files
+          home = RosettAi.paths.global_dir.to_s
+          return [] unless Dir.exist?(home)
+
+          excluded = global_exclusions
+          collect_files_from(home, 'global') do |relative_path|
+            excluded.none? { |pattern| File.fnmatch?(pattern, relative_path, File::FNM_PATHNAME | File::FNM_DOTMATCH) }
+          end
+        end
+
+        def collect_local_files
+          files = []
+          local_dir = RosettAi.paths.local_dir.to_s
+
+          if Dir.exist?(local_dir)
+            files.concat(
+              collect_files_from(local_dir, 'local/.claude') do |relative_path|
+                !File.fnmatch?('settings.local.json', relative_path)
+              end
+            )
+          end
+
+          claude_md = RosettAi.paths.project_claude_md.to_s
+          files << { full_path: claude_md, archive_path: 'local/CLAUDE.md' } if File.exist?(claude_md)
+
+          files
+        end
+
+        def collect_files_from(base_dir, archive_prefix)
+          entries = []
+
+          Dir.glob(File.join(base_dir, '**', '*'), File::FNM_DOTMATCH).each do |full_path|
+            next unless File.file?(full_path)
+
+            relative_path = full_path.sub("#{base_dir}/", '')
+            next unless yield(relative_path)
+
+            entries << { full_path: full_path, archive_path: "#{archive_prefix}/#{relative_path}" }
+          end
+
+          entries
+        end
+
+        def global_exclusions
+          [
+            'settings.local.json',
+            'conf/adopt.cache.yml',
+            'cache/**',
+            'debug/**',
+            'session-env/**',
+            'shell-snapshots/**',
+            'file-history/**',
+            'paste-cache/**',
+            'statsig/**',
+            'todos/**',
+            'plans/**',
+            'plugins/**',
+            'projects/**',
+            'history.jsonl',
+            'stats-cache.json',
+            '.credentials.json',
+            '**/secrets/**',
+            '**/*.pem',
+            '**/*.key',
+            '**/*_rsa',
+            '**/*_ed25519',
+            '**/*.p12',
+            '**/.env',
+            '**/.env.*',
+            '**/credentials.json'
+          ]
+        end
+
+        def create_archive(files, compressor, destination)
+          spinner = start_spinner(t('creating'))
+          temp_archive = Tempfile.new(['rai_backup', compressor.extension])
+          temp_path = temp_archive.path
+          temp_archive.close
+
+          compressor.compress(files, [], temp_path, level: options[:compression_ratio])
+          status = determine_status(temp_path, destination)
+
+          if status == :unchanged
+            finish_spinner(spinner)
+            FileUtils.rm_f(temp_path)
+            dest = resolve_dest_path(destination)
+            return { status: :unchanged, files_count: files.size, destination: dest,
+                     archive_size: File.size(dest) }
+          end
+
+          final_path = destination.write(temp_path)
+          archive_size = File.size(final_path)
+          FileUtils.rm_f(temp_path)
+          finish_spinner(spinner)
+          { status: status, files_count: files.size, destination: final_path, archive_size: archive_size }
+        rescue StandardError => e
+          spinner&.error(Rainbow(t('failed', default: 'Failed')).red)
+          FileUtils.rm_f(temp_path) if temp_path
+          raise RosettAi::BackupError, t('backup_failed', message: e.message)
+        end
+
+        def start_spinner(message)
+          return nil unless RosettAi::Ui::TtyHelper.interactive?
+
+          spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots, clear: true)
+          spinner.auto_spin
+          spinner
+        end
+
+        def finish_spinner(spinner)
+          done_text = t('done', default: 'Done')
+          spinner ? spinner.success(Rainbow(done_text).green) : warn(done_text)
+        end
+
+        def determine_status(temp_path, destination)
+          dest_path = resolve_dest_path(destination)
+          return :created unless dest_path && File.exist?(dest_path)
+
+          new_checksum = Digest::SHA256.file(temp_path).hexdigest
+          existing_checksum = Digest::SHA256.file(dest_path).hexdigest
+
+          new_checksum == existing_checksum ? :unchanged : :updated
+        end
+
+        def resolve_dest_path(destination)
+          destination.respond_to?(:path) ? destination.path : nil
+        end
+
+        def print_summary(result)
+          status_map = {
+            unchanged: [t('status_unchanged'), :green],
+            created: [t('status_created'), :cyan],
+            updated: [t('status_updated'), :cyan]
+          }
+          status_text, color = status_map[result[:status]]
+
+          size_display = format_size(result[:archive_size])
+
+          rows = [
+            ['Status', Rainbow(status_text).send(color)],
+            [t('files_archived'), result[:files_count]],
+            [t('archive_size'), size_display],
+            [t('destination', path: ''), result[:destination]]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('summary_title')).bright,
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        # format_size is provided by RosettAi::Formatting
+
+        def validate_archive!(path)
+          raise ::Thor::Error, t('restore_not_found', path: path) unless File.exist?(path)
+          raise ::Thor::Error, t('restore_not_file', path: path) unless File.file?(path)
+        end
+
+        def extract_entries(archive_path)
+          ext = File.extname(archive_path)
+          case ext
+          when '.gz'
+            extract_tar_gz(archive_path)
+          when '.xz'
+            extract_tar_xz(archive_path)
+          when '.zip'
+            extract_zip(archive_path)
+          else
+            raise ::Thor::Error, t('restore_unknown_format', ext: ext)
+          end
+        end
+
+        def extract_tar_gz(path)
+          entries = {}
+          File.open(path, 'rb') do |file|
+            Zlib::GzipReader.wrap(file) do |gz|
+              Gem::Package::TarReader.new(gz) do |tar|
+                tar.each do |entry|
+                  next unless entry.file?
+
+                  entries[entry.full_name] = entry.read
+                end
+              end
+            end
+          end
+          entries
+        end
+
+        def extract_tar_xz(path)
+          entries = {}
+          IO.popen(['xz', '--decompress', '--stdout', path], 'rb') do |io|
+            Gem::Package::TarReader.new(io) do |tar|
+              tar.each do |entry|
+                next unless entry.file?
+
+                entries[entry.full_name] = entry.read
+              end
+            end
+          end
+          entries
+        end
+
+        def extract_zip(path)
+          require 'zip'
+          entries = {}
+          ::Zip::File.open(path) do |zipfile|
+            zipfile.each do |entry|
+              next if entry.directory?
+
+              entries[entry.name] = entry.get_input_stream.read
+            end
+          end
+          entries
+        end
+
+        def restore_entries(entries)
+          global_dir = RosettAi.paths.global_dir.to_s
+          local_dir = RosettAi.paths.local_dir.to_s
+          project_claude_md = RosettAi.paths.project_claude_md.to_s
+          restored = []
+
+          entries.each do |archive_path, content|
+            target = resolve_restore_target(archive_path, global_dir, local_dir, project_claude_md)
+            next unless target
+            next if archive_path.start_with?('global/') && !options[:global]
+            next if archive_path.start_with?('local/') && !options[:local]
+
+            FileUtils.mkdir_p(File.dirname(target))
+            File.write(target, content)
+            restored << target
+          end
+
+          restored
+        end
+
+        def resolve_restore_target(archive_path, global_dir, local_dir, project_claude_md)
+          case archive_path
+          when %r{^global/(.+)$}
+            File.join(global_dir, Regexp.last_match(1))
+          when 'local/CLAUDE.md'
+            project_claude_md
+          when %r{^local/\.claude/(.+)$}
+            File.join(local_dir, Regexp.last_match(1))
+          end
+        end
+
+        def print_restore_summary(archive_path, restored)
+          rows = [
+            ['Status', Rainbow('Restored').cyan],
+            ['Source', archive_path],
+            ['Files restored', restored.size]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow('Restore Summary').bright,
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+      end
+    end
+  end
+end