kk-git 0.2.4 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8dfe02f8577125ba5e85afa70e08b8d7dff806a5d87378aabc4ce4a57c32857
-  data.tar.gz: dba6e8237452a835805971aa4d9c49d1b84d1af8da53adb53c1c1c32dd6be7f4
+  metadata.gz: ae39abac1e3638de958917ebc2fcbbffdace00c23e13fdd53929cec3e416930f
+  data.tar.gz: eb7191f382ae86ff2c25aac1ce6f7af7a1288be5a25c503641416bcb321ba234
 SHA512:
-  metadata.gz: 94af0ecb6c2baf572aa9d757d4be1ed7f9f2a992c86b44914db30ce6e96808c21ce40af86efe6ddd11f07e62871853bf3505e3c7a2995330c2f7d2d017555e55
-  data.tar.gz: f9dec745963b9b20ff32232b087c58ed5f9259443b52f707ec60cdebe4f5638df182fab95f8b65676774671019d478d04eb0b8ffe14ea392481c164776755363
+  metadata.gz: df09df41cb4383f3654dc161b33703798e069cd16be48dd160162076eca1d03417c7272bb6dc80cdfb7a06c2a46e8a8029597e94c40e6fe5d79e5be9a2f1c6a4
+  data.tar.gz: a52d189d3bf6606506e9fb06f3ff8289926d9f62864e9a2e3628a0657813a009e32840cfda0b2d4e414f3a8b768e940211566f247c06a998db4c9732d29471a9

data/exe/kk-git

@@ -169,6 +169,8 @@ def main_help
       KK_GIT_DEFAULT_TYPE  default type for code edits (default: chore)
       KK_GIT_PUSH_URL       push to explicit URL (bypass SSH remote)
       KK_GIT_PULL_URL       pull from explicit URL (bypass SSH remote)
+      KK_GIT_SKIP_FORMAT=1  skip pre-commit auto-format
+      KK_GIT_FORMAT_ALL=1   format all tracked files (default: changed only)
 
     Run `kk-git <command> --help` for command-specific options.
   HELP

data/lib/kk/git/auto_format.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module KKGit
+  # Best-effort format changed files before commit; skip missing tools.
+  module AutoFormat
+    Language = Struct.new(:id, :label, :extensions, :tools, keyword_init: true)
+
+    Tool = Struct.new(:name, :bin, :argv, keyword_init: true) do
+      def build(files, repo_dir:)
+        bin_path = AutoFormat.resolve_bin(bin, repo_dir: repo_dir)
+        return nil unless bin_path
+
+        args = argv.flat_map { |part| part == '%{files}' ? files : [part] }
+        [bin_path, *args]
+      end
+    end
+
+    LANGUAGES = [
+      Language.new(
+        id: :ruby,
+        label: 'Ruby',
+        extensions: %w[.rb],
+        tools: [
+          Tool.new(name: 'rubocop', bin: 'rubocop', argv: ['-A', '--force-exclusion', '%{files}'])
+        ]
+      ),
+      Language.new(
+        id: :python,
+        label: 'Python',
+        extensions: %w[.py],
+        tools: [
+          Tool.new(name: 'ruff', bin: 'ruff', argv: ['format', '%{files}']),
+          Tool.new(name: 'black', bin: 'black', argv: ['%{files}'])
+        ]
+      ),
+      Language.new(
+        id: :go,
+        label: 'Go',
+        extensions: %w[.go],
+        tools: [
+          Tool.new(name: 'gofmt', bin: 'gofmt', argv: ['-w', '%{files}'])
+        ]
+      ),
+      Language.new(
+        id: :bash,
+        label: 'Bash',
+        extensions: %w[.sh .bash],
+        tools: [
+          Tool.new(name: 'shfmt', bin: 'shfmt', argv: ['-w', '%{files}'])
+        ]
+      ),
+      Language.new(
+        id: :prettier,
+        label: 'JS/TS/Node',
+        extensions: %w[.js .jsx .mjs .cjs .ts .tsx .json .css .scss .less .html .md .yaml .yml],
+        tools: [
+          Tool.new(name: 'prettier', bin: 'prettier', argv: ['--write', '%{files}'])
+        ]
+      )
+    ].freeze
+
+    module_function
+
+    def enabled?
+      ENV['KK_GIT_SKIP_FORMAT'] != '1'
+    end
+
+    def format_all?
+      ENV['KK_GIT_FORMAT_ALL'] == '1'
+    end
+
+    def run!(repo_dir: '.', dry_run: GitOps.dry_run?)
+      return { ran: [], skipped: [], failed: [] } unless enabled?
+
+      files = target_files(repo_dir: repo_dir)
+      grouped = group_files(files)
+      return { ran: [], skipped: [], failed: [] } if grouped.empty?
+
+      ran = []
+      skipped = []
+      failed = []
+
+      grouped.each do |lang_id, paths|
+        language = LANGUAGES.find { |l| l.id == lang_id }
+        next unless language
+
+        tool = pick_tool(language, paths, repo_dir: repo_dir)
+        unless tool
+          skipped << "#{language.label}: no formatter (#{language.tools.map(&:name).join(' / ')})"
+          next
+        end
+
+        cmd = tool.build(paths, repo_dir: repo_dir)
+        label = "#{language.label} (#{tool.name})"
+        if dry_run
+          puts "[dry-run] format #{label}: #{cmd.join(' ')}"
+          ran << label
+          next
+        end
+
+        unless executable?(cmd&.first)
+          skipped << "#{label}: not found (#{tool.name})"
+          next
+        end
+
+        out, err, ok = run_command(cmd, repo_dir: repo_dir)
+        if ok
+          puts "Formatted #{label}: #{paths.length} file(s)"
+          ran << label
+        else
+          msg = err.to_s.strip.empty? ? out.to_s.strip : err.to_s.strip
+          warn "Format failed #{label} (continuing): #{msg.lines.first}"
+          failed << label
+        end
+      end
+
+      skipped.each { |line| puts "Format skip: #{line}" }
+
+      { ran: ran, skipped: skipped, failed: failed }
+    end
+
+    def target_files(repo_dir:)
+      format_all? ? all_tracked_files(repo_dir: repo_dir) : changed_files(repo_dir: repo_dir)
+    end
+
+    def changed_files(repo_dir:)
+      out, _err, ok = GitOps.run_cmd('git', 'status', '--porcelain', '-z', chdir: repo_dir)
+      return [] unless ok
+
+      out.split("\0").filter_map do |entry|
+        next if entry.nil? || entry.empty?
+
+        path = entry[3..]
+        next if path.nil? || path.empty? || path.end_with?('/')
+
+        path
+      end.uniq
+    end
+
+    def all_tracked_files(repo_dir:)
+      out, _err, ok = GitOps.run_cmd('git', 'ls-files', '-z', chdir: repo_dir)
+      return [] unless ok
+
+      out.split("\0").reject(&:empty?)
+    end
+
+    def group_files(files)
+      grouped = Hash.new { |h, k| h[k] = [] }
+      files.each do |path|
+        ext = File.extname(path)
+        language = LANGUAGES.find { |lang| lang.extensions.include?(ext) }
+        grouped[language.id] << path if language
+      end
+      grouped.transform_values { |paths| paths.uniq.sort }
+    end
+
+    def pick_tool(language, _files, repo_dir:)
+      language.tools.find do |tool|
+        resolve_bin(tool.bin, repo_dir: repo_dir)
+      end
+    end
+
+    def resolve_bin(name, repo_dir:)
+      path = which(name)
+      return path if executable?(path)
+
+      local = File.expand_path(File.join(repo_dir, 'node_modules', '.bin', name))
+      return local if executable?(local)
+
+      nil
+    end
+
+    def which(cmd)
+      out, _, ok = Open3.capture3('command', '-v', cmd)
+      return nil unless ok
+
+      path = out.strip
+      path.empty? ? nil : path
+    end
+
+    def executable?(path)
+      path && File.file?(path) && File.executable?(path)
+    end
+
+    def run_command(cmd, repo_dir:)
+      Open3.capture3(*cmd, chdir: repo_dir)
+    rescue Errno::ENOENT, Errno::EACCES => e
+      ['', e.message, false]
+    end
+  end
+end

data/lib/kk/git/git_ops.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'open3'
 require 'tempfile'
 require_relative 'git_runner'
 require_relative 'network_hints'
+require_relative 'auto_format'
 
 module KKGit
   # Git 仓库操作：供 Rake task 与 CLI 复用。
@@ -10,14 +12,16 @@ module KKGit
     class Error < StandardError; end
 
     SENSITIVE_PATH_PATTERNS = [
-      %r{\A\.env(\.|$)}i,
+      /\A\.env(\.|$)/i,
       /credentials/i,
-      %r{\.pem\z}i,
+      /\.pem\z/i,
       /id_rsa/i,
-      %r{\.key\z}i,
-      %r{\Asecrets?\.}i
+      /\.key\z/i,
+      /\Asecrets?\./i
     ].freeze
 
+    SAFE_ENV_TEMPLATE_SUFFIXES = %w[example sample template dist].freeze
+
     # 仓库同步状态快照
     Status = Struct.new(
       :branch, :remote, :clean, :ahead, :behind,
@@ -58,10 +62,14 @@ module KKGit
         ENV.fetch('KK_GIT_REMOTE', 'origin')
       end
 
-      def branch(explicit: ENV['KK_GIT_BRANCH'], repo_dir: '.')
+      def branch(explicit: ENV.fetch('KK_GIT_BRANCH', nil), repo_dir: '.')
         explicit.to_s.strip.empty? ? current_branch(repo_dir: repo_dir) : explicit.to_s.strip
       end
 
+      def skip_format?
+        ENV['KK_GIT_SKIP_FORMAT'] == '1'
+      end
+
       def add_paths
         ENV.fetch('KK_GIT_ADD_PATHS', '.').split(/\s+/).reject(&:empty?)
       end
@@ -113,7 +121,7 @@ module KKGit
       def ensure_ok!(ok, title, stdout: nil, stderr: nil, repo_dir: '.')
         return if ok
 
-        msg = +"#{title} failed"
+        msg = "#{title} failed"
         msg << "\n#{stderr}" unless stderr.to_s.strip.empty?
         msg << "\n#{stdout}" unless stdout.to_s.strip.empty?
 
@@ -252,9 +260,17 @@ module KKGit
       end
 
       def sensitive_path?(path)
+        return false if safe_env_template?(path)
+
         SENSITIVE_PATH_PATTERNS.any? { |pattern| path.match?(pattern) }
       end
 
+      def safe_env_template?(path)
+        SAFE_ENV_TEMPLATE_SUFFIXES.any? do |suffix|
+          path.match?(/\A\.env\.#{suffix}\z/i)
+        end
+      end
+
       def sensitive_staged_paths(repo_dir: '.')
         out, _err, ok = run_cmd('git', 'diff', '--cached', '--name-only', chdir: repo_dir)
         return [] unless ok
@@ -318,6 +334,8 @@ module KKGit
           return :noop
         end
 
+        AutoFormat.run!(repo_dir: repo_dir) unless skip_format?
+
         add_all!(repo_dir: repo_dir)
         ensure_no_sensitive_staged!(repo_dir: repo_dir)
 

data/lib/kk/git/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KKGit
-  VERSION = '0.2.4'
+  VERSION = '0.2.6'
 end

data/lib/kk/git.rb

@@ -5,8 +5,8 @@ require_relative 'git/ruby_warnings'
 require_relative 'git/git_runner'
 require_relative 'git/commit_message'
 require_relative 'git/git_ops'
+require_relative 'git/auto_format'
 require_relative 'git/release'
 
 module KKGit
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kk-git
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: ruby
 authors:
 - kk
@@ -21,6 +21,7 @@ extra_rdoc_files: []
 files:
 - exe/kk-git
 - lib/kk/git.rb
+- lib/kk/git/auto_format.rb
 - lib/kk/git/commit_message.rb
 - lib/kk/git/git_ops.rb
 - lib/kk/git/git_runner.rb