easy_creds 1.0.1

data/lib/easy_creds/thor_cli.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'yaml'
+require 'shellwords'
+require 'tty-screen'
+
+module EasyCreds
+  class ThorCLI < Thor
+    def self.exit_on_failure? = true
+
+    # No-args invocation → styled welcome instead of plain Thor help.
+    def self.start(given_args = ARGV, config = {})
+      given_args.empty? ? new.send(:welcome) : super
+    end
+
+    desc 'sync [ENV]', 'Interactive TUI to sync credentials with 1Password'
+    method_option :vault,        type: :string,  desc: 'Override vault name'
+    method_option :'no-register', type: :boolean, default: false,
+                                  desc: 'Skip the auto-register prompt for unregistered projects'
+    def sync(env = nil)
+      EasyCreds.load_global_config!
+      EasyCreds.ensure_default_template!
+      check_first_run!
+
+      EasyCreds.configure { |c| c.default_vault = options[:vault] } if options[:vault]
+
+      registry = Projects::Registry.load
+      project  = EasyCreds::Project.detect(Dir.pwd)
+
+      if (known = registry.find_by_path(project.root))
+        registry.touch(known)
+        return EasyCreds::CLI.start(project: project, default_env: env)
+      end
+
+      if looks_like_project?(project) && !skip_register?
+        result = Onboarding::RegisterPrompt.run(
+          prompt: build_prompt, project: project, registry: registry
+        )
+        return if result == :quit
+
+        return EasyCreds::CLI.start(project: project, default_env: env)
+      end
+
+      outside_picker_loop(registry)
+    end
+
+    desc 'init', 'First-time gem setup (global config + vault selection)'
+    method_option :'global-dir', type: :string, desc: 'Path to global easy_creds dir'
+    def init
+      EasyCreds.configure { |c| c.global_dir = options[:'global-dir'] } if options[:'global-dir']
+      prompt = build_prompt
+      EasyCreds::Onboarding::GemSetup.run(prompt: prompt)
+    end
+
+    desc 'onboard', 'Set up example.yml for the current project'
+    method_option :template, type: :string, desc: 'Template name to use'
+    method_option :force, type: :boolean, default: false, desc: 'Overwrite existing example.yml'
+    def onboard
+      EasyCreds.load_global_config!
+      project = EasyCreds::Project.detect(Dir.pwd)
+      EasyCreds::Onboarding::Runner.start(project: project, template: options[:template], force: options[:force])
+    end
+
+    desc 'doctor', 'Check gem health (op CLI, auth, project detection)'
+    method_option :verbose, type: :boolean, default: false
+    def doctor
+      EasyCreds.load_global_config!
+      ok = EasyCreds::Doctor.new(verbose: options[:verbose]).run
+      exit 1 unless ok
+    end
+
+    desc 'install', 'Install overlay initializer into current Rails project'
+    def install
+      project = EasyCreds::Project.detect(Dir.pwd)
+      unless project.is_a?(EasyCreds::Project::Rails)
+        puts EasyCreds::Theme.warn('Not a Rails project — nothing to install.')
+        exit 3
+      end
+      EasyCreds::Installer.new(project.root).run
+    end
+
+    desc 'projects', 'Browse and manage registered projects'
+    def projects
+      EasyCreds.load_global_config!
+      registry = Projects::Registry.load
+      outside_picker_loop(registry)
+    end
+
+    desc 'templates', 'Browse and manage global template library'
+    def templates
+      EasyCreds.load_global_config!
+      Views::TemplatesMenu.run(build_prompt)
+    end
+
+    desc 'settings', 'Edit global easy_creds settings'
+    def settings
+      EasyCreds.load_global_config!
+      Views::SettingsMenu.run(build_prompt)
+    end
+
+    desc 'tree', 'Print a tree of all available commands'
+    def tree
+      render_command_tree
+    end
+
+    desc 'version', 'Print easy_creds version'
+    def version
+      beastmode_version
+    end
+
+    private
+
+    COMMAND_GROUPS = {
+      'Setup'   => %w[init onboard install doctor],
+      'Sync'    => %w[sync],
+      'Manage'  => %w[projects templates settings],
+      'Utility' => %w[tree version help]
+    }.freeze
+    private_constant :COMMAND_GROUPS
+
+    def welcome
+      EasyCreds.load_global_config!
+      width = [TTY::Screen.width, 100].min
+      inner = width - 4
+
+      # ASCII art banner in rounded box
+      art_lines = Theme::BANNER_ART.map { |l| "  #{Theme.accent(l)}" }
+      vault      = EasyCreds.config.default_vault
+      art_lines << ''
+      art_lines << "  #{Theme.dim("v#{EasyCreds::VERSION}  ·  credentials ↔ 1Password sync  ·  vault: #{vault || '(not set)'}")}"
+      rows = art_lines.map { |l| "#{Theme.box_side} #{Theme.rpad(l, inner)} #{Theme.box_side}" }
+      puts ''
+      puts Theme.box_top(width)
+      puts rows
+      puts Theme.box_bottom(width)
+      puts ''
+      puts "  #{Theme.tprompt_line}"
+      puts ''
+
+      registry = Projects::Registry.load
+      if registry.projects.any?
+        puts "  #{Theme.bold('Recent projects:')}"
+        puts ''
+        registry.projects
+                .sort_by { |pr| -(pr.last_seen_at&.to_i || 0) }
+                .first(3)
+                .each do |pr|
+          seen = Views::ProjectPicker.relative_time(pr.last_seen_at)
+          kind = pr.rails? ? Theme.ok('[rails]') : Theme.accent('[std]')
+          puts "  #{Theme.accent('›')} #{Theme.bold(pr.name.ljust(22))} #{kind}  #{Theme.dim(pr.display_path)}  #{Theme.dim(seen)}"
+        end
+        puts ''
+      elsif first_run?
+        puts "  #{Theme.warn('→ First time?')}  Run #{Theme.accent(Theme.bold('easy_creds init'))} to get started."
+        puts ''
+      end
+
+      puts "  #{Theme.bold('Commands:')}"
+      puts ''
+      cmds  = self.class.commands
+      max_w = cmds.keys.map(&:length).max || 0
+      cmds.sort.each do |name, cmd|
+        puts "  easy_creds #{Theme.accent(Theme.bold(name.ljust(max_w + 1)))}  #{Theme.dim('# ' + cmd.description)}"
+      end
+      puts ''
+      puts "  #{Theme.dim('Run')} #{Theme.bold('easy_creds help [COMMAND]')} #{Theme.dim('for details.')}"
+      puts ''
+    end
+
+    def outside_picker_loop(registry)
+      prompt = build_prompt
+      loop do
+        system('clear')
+        choice = Views::WelcomeScreen.run(registry)
+
+        case choice
+        when :quit then break
+        when :templates
+          system('clear')
+          Views::TemplatesMenu.run(prompt)
+        when :settings
+          system('clear')
+          Views::SettingsMenu.run(prompt)
+        when :init_here
+          system('clear')
+          init_here(prompt, registry) and break
+        when EasyCreds::Projects::Project
+          handle_project_pick(choice, registry)
+          break
+        end
+      end
+    end
+
+    def handle_project_pick(project, registry)
+      unless project.exists_on_disk?
+        prompt = build_prompt
+        if prompt.yes?("Path #{project.path} no longer exists. Remove from registry?", default: true)
+          registry.remove(project)
+        end
+        return
+      end
+
+      registry.touch(project)
+      Dir.chdir(project.path) do
+        detected = EasyCreds::Project.detect(project.path)
+        EasyCreds::CLI.start(project: detected, default_env: nil)
+      end
+    end
+
+    def init_here(prompt, registry)
+      project = EasyCreds::Project.detect(Dir.pwd)
+      result  = Onboarding::RegisterPrompt.run(prompt: prompt, project: project, registry: registry)
+      return false if result == :quit
+
+      EasyCreds::CLI.start(project: project, default_env: nil)
+      true
+    end
+
+    def render_command_tree
+      p = Theme.pastel
+      puts ''
+      puts "  #{Theme.header('easy_creds')}  #{Theme.dim('v' + EasyCreds::VERSION)}"
+      puts "  #{Theme.dim('─' * 50)}"
+      puts ''
+
+      rendered = []
+      COMMAND_GROUPS.each do |group_name, cmd_names|
+        available = cmd_names.select { |n| self.class.commands.key?(n) }
+        next if available.empty?
+
+        puts "  #{Theme.bold(group_name)}"
+        available.each_with_index do |name, i|
+          cmd       = self.class.commands[name]
+          connector = i == available.size - 1 ? '└─' : '├─'
+          puts "  #{Theme.dim(connector)} #{Theme.accent(name.ljust(12))}  #{Theme.dim(cmd.description)}"
+          rendered << name
+        end
+        puts ''
+      end
+
+      remaining = self.class.commands.keys.sort - rendered
+      if remaining.any?
+        puts "  #{Theme.bold('Other')}"
+        remaining.each_with_index do |name, i|
+          cmd       = self.class.commands[name]
+          connector = i == remaining.size - 1 ? '└─' : '├─'
+          puts "  #{Theme.dim(connector)} #{Theme.accent(name.ljust(12))}  #{Theme.dim(cmd.description)}"
+        end
+        puts ''
+      end
+    end
+
+    def beastmode_version
+      width  = 48
+      inner  = width - 4
+
+      lines = [
+        "  #{Theme.header("#{Theme::ICONS[:lock]}  easy_creds")}  #{Theme.dim("v#{EasyCreds::VERSION}")}",
+        '',
+        "  #{Theme.dim("Ruby #{RUBY_VERSION} · #{RUBY_PLATFORM}")}"
+      ]
+
+      rows = lines.map { |l| "#{Theme.box_side} #{Theme.rpad(l, inner)} #{Theme.box_side}" }
+      box  = ([Theme.box_top(width)] + rows + [Theme.box_bottom(width)]).join("\n")
+
+      puts ''
+      puts box.split("\n").map { |l| "  #{l}" }.join("\n")
+      puts ''
+      puts "  #{Theme.accent(Theme.bold('B E A S T M O D E'))}  #{Theme.dim('activated ⚡')}"
+      puts ''
+    end
+
+    def check_first_run!
+      return unless first_run?
+
+      puts ''
+      puts "  #{Theme.warn("#{Theme::ICONS[:warn]} First run detected!")}  #{Theme.dim('Setting up easy_creds...')}"
+      puts ''
+      EasyCreds::Onboarding::GemSetup.run(prompt: build_prompt)
+    end
+
+    def first_run?
+      !File.exist?(File.join(EasyCreds.config.global_dir, 'config.yml'))
+    end
+
+    def looks_like_project?(project)
+      project.rails? || File.directory?(File.join(project.root.to_s, '.git'))
+    end
+
+    def skip_register?
+      options[:'no-register'] || ENV['EASY_CREDS_NO_REGISTER']
+    end
+
+    def build_prompt
+      TTY::Prompt.new(interrupt: :exit, symbols: { selector: '›' })
+    end
+  end
+end

data/lib/easy_creds/vault_picker.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module EasyCreds
+  module VaultPicker
+    CREATE_SENTINEL = :'__create_new__'
+    DEFAULT_NEW_NAME = 'easy_creds'
+
+    # Shows existing 1Password vaults + a "create new" option.
+    # Returns the chosen vault name (string), or nil if the user aborts.
+    def self.pick(prompt)
+      vaults = fetch_vaults
+
+      choices = vaults.map { |v| { name: "  #{v}", value: v } }
+
+      if choices.any?
+        choices << { name: Theme.pastel.dim('  ─────────────────────────────────'), value: nil, disabled: '' }
+      end
+
+      choices << { name: "  #{Theme.pastel.bold('✚ create new vault…')}", value: CREATE_SENTINEL }
+
+      selection = prompt.select('Select default vault:', choices, cycle: true, filter: false,
+                                per_page: [choices.size, 20].min)
+
+      return nil if selection.nil?
+      return selection unless selection == CREATE_SENTINEL
+
+      create_vault(prompt)
+    end
+
+    def self.fetch_vaults
+      raw = `op vault list --format=json 2>/dev/null`
+      return [] unless $CHILD_STATUS.success?
+
+      JSON.parse(raw).map { |v| v['name'] }
+    rescue JSON::ParserError
+      []
+    end
+
+    def self.create_vault(prompt)
+      name = prompt.ask('New vault name:', default: DEFAULT_NEW_NAME) do |q|
+        q.validate(/\S+/, 'Vault name cannot be blank.')
+      end
+      return nil unless name
+
+      name = name.strip
+      output = `op vault create #{Shellwords.escape(name)} 2>&1`
+      if $CHILD_STATUS.success?
+        Theme.success("Created vault '#{name}'")
+        name
+      else
+        Theme.failure("Could not create vault: #{output.strip}")
+        nil
+      end
+    end
+  end
+end

data/lib/easy_creds/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EasyCreds
+  VERSION = '1.0.1'
+end

data/lib/easy_creds/views/diff_table.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'tty-table'
+
+module EasyCreds
+  module Views
+    module DiffTable
+      HEADER = %w[change key where].freeze
+
+      CHANGE_LABELS = { added: 'remote-only', removed: 'local-only', modified: 'differs' }.freeze
+
+      def self.render(changes)
+        if changes.empty?
+          puts Theme.ok('  (no changes — already in sync)')
+          return
+        end
+
+        puts build_table(changes)
+        puts Theme.dim("  #{changes.size} change(s) — values not shown")
+      end
+
+      private_class_method def self.build_table(changes)
+        rows = changes.map { |c| change_row(c) }
+        TTY::Table.new(HEADER, rows).render(:unicode, padding: [0, 1])
+      end
+
+      private_class_method def self.change_row(change)
+        [
+          "#{Theme.change_color(change.kind)} #{CHANGE_LABELS[change.kind]}",
+          Theme.key_tag(change.key),
+          Theme.dim(change.side.to_s)
+        ]
+      end
+    end
+  end
+end

data/lib/easy_creds/views/header.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module EasyCreds
+  module Views
+    module Header
+      def self.render(ctx)
+        system('clear') || system('cls')
+        puts Theme.banner(ctx.config.vault, EnvPicker.available(ctx.root))
+        puts ''
+        puts "  #{Theme.tprompt_line}"
+        puts ''
+        puts sign_in_line(ctx.op&.account_email)
+        puts env_vault_line(ctx)
+        puts project_line(ctx.root)
+        puts ''
+      end
+
+      private_class_method def self.sign_in_line(email)
+        if email
+          "  #{Theme.ok(Theme::ICONS[:ok])}  signed in to 1Password  #{Theme.dim("(#{email})")}"
+        else
+          "  #{Theme.error(Theme::ICONS[:error])}  not signed in to 1Password"
+        end
+      end
+
+      private_class_method def self.env_vault_line(ctx)
+        env_label   = ctx.env   ? Theme.env_tag(ctx.env)                : Theme.dim('none selected')
+        vault_label = ctx.config.vault ? Theme.bold(ctx.config.vault) : Theme.dim('(not set)')
+        "  #{Theme.dim('env')}      #{env_label}   #{Theme.dim('vault')} #{vault_label}"
+      end
+
+      private_class_method def self.project_line(root)
+        project = Project.detect(root)
+        kind    = project.rails? ? Theme.ok('Rails') : Theme.accent('Standalone')
+        path    = Theme.dim(root.to_s.gsub(Dir.home, '~'))
+        "  #{Theme.dim('project')}  #{kind}  #{path}"
+      end
+    end
+  end
+end

data/lib/easy_creds/views/init_dispatch.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module EasyCreds
+  module Views
+    # Pure keystroke → state mutation dispatcher.
+    # Returns nil (normal redraw), or a signal symbol:
+    #   :manual_entry  — caller must prompt for hidden input
+    #   :save          — caller should write the file and exit
+    #   :quit          — caller should confirm and exit
+    #   :toggle_help   — caller flips the help overlay flag
+    module InitDispatch
+      UP        = ["\e[A", 'k'].freeze
+      DOWN      = ["\e[B", 'j'].freeze
+      PAGE_UP   = ["\e[5~", "\e[I"].freeze
+      PAGE_DOWN = ["\e[6~", "\e[G"].freeze
+      HOME_KEY  = ["\e[H", "\e[1~", "\eOH"].freeze
+      END_KEY   = ["\e[F", "\e[4~", "\eOF"].freeze
+
+      # Keys that return a signal directly without touching state.
+      SIGNAL_KEYS = {
+        'm' => :manual_entry,
+        's' => :save, 'S' => :save,
+        'q' => :quit, "\e" => :quit,
+        '?' => :toggle_help, 'h' => :toggle_help
+      }.freeze
+
+      # Returns nil (redraw) or a signal symbol (:manual_entry, :save, :quit, :toggle_help).
+      def self.handle(key, state, root: nil)
+        nav = navigate(key, state)
+        return nav unless nav == :not_navigation
+
+        SIGNAL_KEYS.fetch(key) { mutate(key, state, root: root) }
+      end
+
+      private_class_method def self.navigate(key, state)
+        case key
+        when *UP        then state.move_up
+        when *DOWN      then state.move_down
+        when *PAGE_UP   then state.move_up(10)
+        when *PAGE_DOWN then state.move_down(10)
+        when *HOME_KEY  then state.move_first
+        when *END_KEY   then state.move_last
+        else return :not_navigation
+        end
+        nil
+      end
+
+      private_class_method def self.mutate(key, state, root: nil)
+        case key
+        when 'g' then apply_generate(state, root: root)
+        when 'G' then apply_generate_alt(state)
+        when 'b' then apply_ar_batch(state, root: root)
+        when 't' then apply_template(state)
+        when 'o' then apply_from_op(state)
+        when 'c' then state.clear_entry(state.current)
+        when 'T' then template_all(state)
+        when 'R' then generate_suggested(state, root: root)
+        when 'O' then from_op_all(state)
+        end
+        nil
+      end
+
+      private_class_method def self.apply_generate(state, root: nil)
+        entry = state.current
+        if entry.hint == :ar_encryption
+          apply_ar_batch(state, root: root)
+        else
+          val = Generators.default_for(entry.hint, root: root)
+          state.set_entry(entry, value: val.to_s, source: :generate) if val
+        end
+      end
+
+      private_class_method def self.apply_generate_alt(state)
+        entry = state.current
+        return if entry.hint == :ar_encryption
+
+        val = Generators.alternative_for(entry.hint)
+        state.set_entry(entry, value: val.to_s, source: :generate_alt) if val
+      end
+
+      private_class_method def self.apply_ar_batch(state, root: nil)
+        keys = Generators.ar_encryption_keys(root)
+        return unless keys
+
+        keys.each do |key, val|
+          entry = state.entries.find { |e| e.key == key }
+          state.set_entry(entry, value: val.to_s, source: :ar_batch) if entry
+        end
+      end
+
+      private_class_method def self.apply_template(state)
+        entry = state.current
+        return unless entry.placeholder
+
+        state.set_entry(entry, value: entry.placeholder.to_s, source: :template)
+      end
+
+      private_class_method def self.apply_from_op(state)
+        entry = state.current
+        val   = entry.op_value
+        state.set_entry(entry, value: val.to_s, source: :from_op) if val
+      end
+
+      private_class_method def self.template_all(state)
+        state.entries.each do |entry|
+          next if entry.set? || entry.placeholder.nil?
+
+          state.set_entry(entry, value: entry.placeholder.to_s, source: :template)
+        end
+      end
+
+      private_class_method def self.generate_suggested(state, root: nil)
+        apply_ar_batch(state, root: root) if state.entries.any? { |e| e.hint == :ar_encryption && !e.set? }
+
+        state.entries.each do |entry|
+          next if entry.set? || entry.hint.nil? || entry.hint == :ar_encryption
+
+          val = Generators.bulk_for(entry.hint)
+          state.set_entry(entry, value: val.to_s, source: :generate) if val
+        end
+      end
+
+      private_class_method def self.from_op_all(state)
+        state.entries.each do |entry|
+          next if entry.set? || entry.op_value.nil?
+
+          state.set_entry(entry, value: entry.op_value.to_s, source: :from_op)
+        end
+      end
+    end
+  end
+end