hank 0.1.0

data/lib/hank/hankfile.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Hank
+  # Manages the Hankfile configuration
+  class Hankfile
+    extend T::Sig
+
+    sig { returns(T::Hash[String, String]) }
+    attr_reader :mappings
+
+    sig { void }
+    def initialize
+      @mappings = T.let({}, T::Hash[String, String])
+    end
+
+    sig { params(source_path: String, target_path: String).void }
+    def add_mapping(source_path, target_path)
+      @mappings[source_path] = target_path
+    end
+
+    sig { params(source_path: String).void }
+    def remove_mapping(source_path)
+      @mappings.delete(source_path)
+    end
+
+    sig { params(selected_files: T::Array[String]).void }
+    def update_mappings(selected_files)
+      # Keep mappings for selected files, add new ones
+      new_mappings = {}
+
+      selected_files.each do |source_path|
+        new_mappings[source_path] = if @mappings.key?(source_path)
+                                      @mappings[source_path]
+                                    else
+                                      PathUtils.flatten_path(source_path)
+                                    end
+      end
+
+      @mappings = new_mappings
+      save
+    end
+
+    sig { void }
+    def save
+      path = ENV['HANKFILE'] || 'Hankfile'
+      File.write(path, to_s)
+    end
+
+    sig { returns(String) }
+    def to_s
+      TomlRB.dump({ 'mappings' => @mappings })
+    end
+
+    sig { params(file_path: Pathname).returns(Hankfile) }
+    def self.from_file(file_path)
+      content = File.read(file_path)
+      data = TomlRB.parse(content)
+
+      hankfile = Hankfile.new
+      if data['mappings'].is_a?(Hash)
+        data['mappings'].each do |source_path, target_path|
+          hankfile.add_mapping(source_path, target_path.to_s)
+        end
+      end
+
+      hankfile
+    end
+  end
+end

data/lib/hank/path_utils.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Hank
+  # Utilities for path manipulation and file type detection
+  class PathUtils
+    extend T::Sig
+
+    sig { params(path: String).returns(String) }
+    def self.flatten_path(path)
+      pathname = Pathname.new(path)
+
+      # Handle dotfiles
+      basename = pathname.basename.to_s
+      basename = "dot--#{basename[1..]}" if basename.start_with?('.')
+
+      # Flatten directory structure
+      if pathname.dirname.to_s == '.'
+        basename
+      else
+        dirname = pathname.dirname.to_s.gsub(%r{^/}, '').gsub('/', '-')
+        "#{dirname}-#{basename}"
+      end
+    end
+
+    sig { params(path: String).returns(T::Boolean) }
+    def self.text_file?(path)
+      return false unless File.file?(path)
+
+      # Use libmagic to determine if file is text
+      begin
+        # Create a new instance for each call to avoid allocator warnings
+        magic = FileMagic.open(FileMagic::MAGIC_MIME)
+        mime_type = magic.file(path)
+        magic.close
+        mime_type.start_with?('text/') ||
+          mime_type.include?('xml') ||
+          mime_type.include?('json') ||
+          mime_type.include?('script')
+      rescue StandardError => e
+        puts "Warning: Error detecting file type: #{e.message}".yellow
+        # Fall back to simple text check
+        File.open(path) { |f| T.must(f.read(1024)).valid_encoding? }
+      end
+    end
+  end
+end

data/lib/hank/symlink_manager.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Hank
+  # Manages creation and removal of symlinks
+  class SymlinkManager
+    extend T::Sig
+
+    sig { returns(Pathname) }
+    attr_reader :base_dir
+
+    sig { params(hankfile: Hankfile).void }
+    def initialize(hankfile)
+      @hankfile = T.let(hankfile, Hankfile)
+      @base_dir = T.let(Pathname.new(Dir.pwd), Pathname)
+    end
+
+    sig { void }
+    def install_all
+      @hankfile.mappings.each do |source_path, target_path|
+        create_symlink(source_path, target_path)
+      end
+      @hankfile.save
+    end
+
+    sig { params(source: Pathname, target: Pathname).void }
+    def create_empty_target(source, target)
+      if source.directory?
+        FileUtils.mkdir_p(target)
+      else
+        FileUtils.touch(target)
+      end
+    end
+
+    sig { params(source_path: String, target_path: String, force: T::Boolean).returns(T::Boolean) }
+    def create_symlink(source_path, target_path, force: false)
+      source = Pathname.new(source_path)
+      target = @base_dir.join(target_path)
+
+      # Ensure the source path directory exists
+      FileUtils.mkdir_p(source.dirname) unless source.dirname.directory?
+
+      # Ensure the target exists
+      unless target.exist?
+        if source.exist?
+          if source.directory? || (!source.symlink? && source.file?)
+            # Move the entire directory or file to the target location
+            FileUtils.mv(source, target)
+          else
+            # Create empty file or directory as needed
+            create_empty_target(source, target)
+          end
+        elsif source_path.end_with?('/')
+          # Create empty file or directory based on the source path name
+          # (If we can infer it's supposed to be a directory)
+          FileUtils.mkdir_p(target)
+        else
+          FileUtils.touch(target)
+        end
+      end
+
+      # Handle existing destination
+      if source.exist?
+        if source.symlink? && !force
+          return false
+
+          # Remove existing symlink if force is specified
+
+          # Skip if symlink already exists and force is not specified
+
+        end
+
+        FileUtils.rm_rf(source)
+      end
+
+      # Create the symlink
+      begin
+        FileUtils.ln_s(target.to_s, source.to_s)
+        puts "Created symlink: #{source} -> #{target}".green
+        true
+      rescue StandardError => e
+        puts "⚠️ Failed to create symlink: #{source} -> #{target}: #{e.message}".red
+        false
+      end
+    end
+
+    sig { params(source_path: String).void }
+    def remove_mapping(source_path)
+      @hankfile.remove_mapping(source_path)
+      @hankfile.save
+      puts "Removed #{source_path} from Hankfile".green
+    end
+  end
+end

data/lib/hank/validator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Hank
+  # Validates the integrity of symlinks
+  class Validator
+    extend T::Sig
+
+    # Represents a validation issue with a symlink
+    class Issue < T::Struct
+      const :type, Symbol # :missing, :wrong_target, :not_symlink
+      const :source_path, String
+      const :target_path, String
+      const :current_target, T.nilable(String)
+    end
+
+    sig { params(hankfile: Hankfile).void }
+    def initialize(hankfile)
+      @hankfile = T.let(hankfile, Hankfile)
+      @base_dir = T.let(Pathname.new(Dir.pwd), Pathname)
+    end
+
+    sig { returns(T::Array[Issue]) }
+    def validate
+      issues = []
+
+      @hankfile.mappings.each do |source_path, target_path|
+        source = Pathname.new(source_path)
+        target = @base_dir.join(target_path)
+
+        if !source.exist?
+          # Source path doesn't exist
+          issues << Issue.new(
+            type: :missing,
+            source_path: source_path,
+            target_path: target_path,
+            current_target: nil
+          )
+        elsif !source.symlink?
+          # Source path exists but is not a symlink
+          issues << Issue.new(
+            type: :not_symlink,
+            source_path: source_path,
+            target_path: target_path,
+            current_target: nil
+          )
+        else
+          # Source path is a symlink, check if it points to the correct target
+          actual_target = Pathname.new(File.readlink(source.to_s))
+
+          if actual_target != target && actual_target.expand_path != target.expand_path
+            issues << Issue.new(
+              type: :wrong_target,
+              source_path: source_path,
+              target_path: target_path,
+              current_target: actual_target.to_s
+            )
+          end
+        end
+      end
+
+      issues
+    end
+  end
+end

data/lib/hank/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Hank
+  VERSION = '0.1.0'
+end

data/lib/hank.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+# typed: strict
+
+require 'sorbet-runtime'
+require 'thor'
+require 'toml-rb'
+require 'filemagic'
+require 'diffy'
+require 'colorize'
+require 'pathname'
+require 'fileutils'
+require 'curses'
+
+require_relative 'hank/version'
+require_relative 'hank/hankfile'
+require_relative 'hank/path_utils'
+require_relative 'hank/symlink_manager'
+require_relative 'hank/file_selector'
+require_relative 'hank/validator'
+require_relative 'hank/cli'
+
+module Hank
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sorbet/config

@@ -0,0 +1,5 @@
+--dir
+.
+--ignore=/tmp/
+--ignore=/vendor/bundle
+--ignore=sorbet/rbi/gems/thor@1.3.2.rbi

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/colorize.rbi

@@ -0,0 +1,121 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class String
+  extend Colorize::ClassMethods
+  include Colorize::InstanceMethods
+
+  sig { returns(String) }
+  def black; end
+
+  sig { returns(String) }
+  def blink; end
+
+  sig { returns(String) }
+  def blue; end
+
+  sig { returns(String) }
+  def bold; end
+
+  sig { returns(String) }
+  def cyan; end
+
+  sig { returns(String) }
+  def green; end
+
+  sig { returns(String) }
+  def hide; end
+
+  sig { returns(String) }
+  def italic; end
+
+  sig { returns(String) }
+  def light_black; end
+
+  sig { returns(String) }
+  def light_blue; end
+
+  sig { returns(String) }
+  def light_cyan; end
+
+  sig { returns(String) }
+  def light_green; end
+
+  sig { returns(String) }
+  def light_magenta; end
+
+  sig { returns(String) }
+  def light_red; end
+
+  sig { returns(String) }
+  def light_white; end
+
+  sig { returns(String) }
+  def light_yellow; end
+
+  sig { returns(String) }
+  def magenta; end
+
+  sig { returns(String) }
+  def on_black; end
+
+  sig { returns(String) }
+  def on_blue; end
+
+  sig { returns(String) }
+  def on_cyan; end
+
+  sig { returns(String) }
+  def on_green; end
+
+  sig { returns(String) }
+  def on_light_black; end
+
+  sig { returns(String) }
+  def on_light_blue; end
+
+  sig { returns(String) }
+  def on_light_cyan; end
+
+  sig { returns(String) }
+  def on_light_green; end
+
+  sig { returns(String) }
+  def on_light_magenta; end
+
+  sig { returns(String) }
+  def on_light_red; end
+
+  sig { returns(String) }
+  def on_light_white; end
+
+  sig { returns(String) }
+  def on_light_yellow; end
+
+  sig { returns(String) }
+  def on_magenta; end
+
+  sig { returns(String) }
+  def on_red; end
+
+  sig { returns(String) }
+  def on_white; end
+
+  sig { returns(String) }
+  def on_yellow; end
+
+  sig { returns(String) }
+  def red; end
+
+  sig { returns(String) }
+  def underline; end
+
+  sig { returns(String) }
+  def white; end
+
+  sig { returns(String) }
+  def yellow; end
+end

data/sorbet/rbi/annotations/minitest.rbi

@@ -0,0 +1,119 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Minitest::Assertions
+  sig { params(test: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert(test, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_empty(obj, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_equal(exp, act, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, delta: Numeric, msg: T.anything).returns(TrueClass) }
+  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = nil); end
+
+  sig { params(a: T.anything, b: T.anything, epsilon: Numeric, msg: T.anything).returns(TrueClass) }
+  def assert_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = nil); end
+
+  sig { params(collection: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_includes(collection, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_instance_of(cls, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_kind_of(cls, obj, msg = nil); end
+
+  sig { params(matcher: T.any(String, Regexp), obj: T.anything, msg: T.anything).returns(MatchData) }
+  def assert_match(matcher, obj, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_nil(obj, msg = nil); end
+
+  sig { params(o1: T.anything, op: T.any(Symbol, String), o2: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = nil); end
+
+  sig { params(stdout: T.nilable(T.any(String, Regexp)), stderr: T.nilable(T.any(String, Regexp)), block: T.proc.void).returns(T::Boolean) }
+  def assert_output(stdout = nil, stderr = nil, &block); end
+
+  sig { params(path: T.any(String, Pathname), msg: T.anything).returns(TrueClass) }
+  def assert_path_exists(path, msg = nil); end
+
+  sig { params(block: T.proc.void).returns(TrueClass) }
+  def assert_pattern(&block); end
+
+  sig { params(o1: T.anything, op: T.any(String, Symbol), msg: T.anything).returns(TrueClass) }
+  def assert_predicate(o1, op, msg = nil); end
+
+  sig { params(exp: NilClass, block: T.proc.void).returns(StandardError) }
+  sig { type_parameters(:T).params(exp: T.any(T::Class[T.type_parameter(:T)], Regexp, String), block: T.proc.void).returns(T.type_parameter(:T)) }
+  def assert_raises(*exp, &block); end
+
+  sig { params(obj: T.anything, meth: T.any(String, Symbol), msg: T.anything, include_all: T::Boolean).returns(TrueClass) }
+  def assert_respond_to(obj, meth, msg = nil, include_all: false); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def assert_same(exp, act, msg = nil); end
+
+  sig { params(send_ary: T::Array[T.anything], m: T.anything).returns(T::Boolean) }
+  def assert_send(send_ary, m = nil); end
+
+  sig { params(block: T.proc.void).returns(T::Boolean) }
+  def assert_silent(&block); end
+
+  sig { params(sym: Symbol, msg: T.anything, block: T.proc.void).returns(T.anything) }
+  def assert_throws(sym, msg = nil, &block); end
+
+  sig { params(test: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute(test, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_empty(obj, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_equal(exp, act, msg = nil); end
+
+  sig { params(exp: T.anything, act: T.anything, delta: Numeric, msg: T.anything).returns(TrueClass) }
+  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = nil); end
+
+  sig { params(a: T.anything, b: T.anything, epsilon: Numeric, msg: T.anything).returns(TrueClass) }
+  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = nil); end
+
+  sig { params(collection: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_includes(collection, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_instance_of(cls, obj, msg = nil); end
+
+  sig { params(cls: T.anything, obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_kind_of(cls, obj, msg = nil); end
+
+  sig { params(matcher: T.any(String, Regexp), obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_match(matcher, obj, msg = nil); end
+
+  sig { params(obj: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_nil(obj, msg = nil); end
+
+  sig { params(block: T.proc.void).returns(TrueClass) }
+  def refute_pattern(&block); end
+
+  sig { params(o1: T.anything, op: T.any(Symbol, String), o2: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = nil); end
+
+  sig { params(path: T.any(String, Pathname), msg: T.anything).returns(TrueClass) }
+  def refute_path_exists(path, msg = nil); end
+
+  sig { params(o1: T.anything, op: T.any(String, Symbol), msg: T.anything).returns(TrueClass) }
+  def refute_predicate(o1, op, msg = nil); end
+
+  sig { params(obj: T.anything, meth: T.any(String, Symbol), msg: T.anything, include_all: T::Boolean).returns(TrueClass) }
+  def refute_respond_to(obj, meth, msg = nil, include_all: false); end
+
+  sig { params(exp: T.anything, act: T.anything, msg: T.anything).returns(TrueClass) }
+  def refute_same(exp, act, msg = nil); end
+end