kk-git 0.1.7 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf8344aceea8482a3025d31bbcc1293cd6a4fd6aaa3235c3907cf173538e83e5
-  data.tar.gz: 553a278a015110d0205d9da2e2df75d83429b169428c23fb1d75ca40a139c140
+  metadata.gz: 74daf125db0cf895ef3d9c7c6e0315f56a70a1e5de4cfff743ed0bb281d9c73c
+  data.tar.gz: 0dda4d4d4544b1249d3b95a019ea4da0f6d9d1469b3815b21c5069ea213a2ca6
 SHA512:
-  metadata.gz: f9a2764f0d336ef4ce214133e63d9b8cad0c68d481d95b88ff0f00feca8d358199a1687c37e95bc563eea8758f85c46ee90f9826621cfe5db168cd75087a46e3
-  data.tar.gz: 58e748e4640395c28e9e27c805e36d3b5ed1fc997e55fcfc9c0d4649fdbe593aaf3c22e39d3d25f82acca5408e71516211118691690a288b6181bc8f01a758c6
+  metadata.gz: f9b644cfda470263d0bdef6073c8adf2fa9864d24388e8af13053ce684996c2ec62f2a90d131b82eb9d5daa7c6d073d8d061571ac21c63887d0e0454fe8fdfdf
+  data.tar.gz: 59a25a6ad4c915ebe7a48f128ad501585340f9ffc3f9ecccc47bb9303729ac2286783b1ea08e1e18128e075a4d2beb5ece410d59d8435ba09cf1cfb0690578d5

data/exe/kk-git

@@ -10,110 +10,174 @@ rescue LoadError
   require_relative '../lib/kk/git'
 end
 
-options = {
-  mode: :staged,
-  format: :text,
-  include_body: true,
-  repo_dir: '.',
-  type: nil,
-  scope: nil,
-  subject: nil,
-  detect_breaking: true
-}
-
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage:\n" \
-                "  kk-git --version\n" \
-                "  kk-git commit-message [options]\n\n" \
-                "Generate Conventional Commits messages from git changes."
-
-  opts.on('--repo DIR', 'Git repo directory (default: current dir)') { |v| options[:repo_dir] = v }
-
-  opts.on('--staged', 'Use staged changes only (default)') { options[:mode] = :staged }
-  opts.on('--worktree', 'Use working-tree changes only (includes untracked)') { options[:mode] = :worktree }
-  opts.on('--all', 'Combine staged + working-tree changes') { options[:mode] = :all }
-
-  opts.on('--[no-]body', 'Include body for multi-file changes (default: yes)') { |v| options[:include_body] = v }
-
-  opts.on('--type TYPE', 'Override inferred type (feat/fix/docs/...)') { |v| options[:type] = v }
-  opts.on('--scope SCOPE', 'Override inferred scope') { |v| options[:scope] = v }
-  opts.on('--subject SUBJECT', 'Override inferred subject') { |v| options[:subject] = v }
-  opts.on('--[no-]detect-breaking', 'Detect BREAKING markers (default: yes)') { |v| options[:detect_breaking] = v }
-
-  opts.on('--format FORMAT', 'Output format: text/json (default: text)') do |v|
-    options[:format] = v.to_s.downcase.to_sym
+def to_utf8(str)
+  return nil if str.nil?
+
+  s = str.to_s.dup
+  s.force_encoding(Encoding::UTF_8)
+  s.scrub('�')
+end
+
+def run_commit_message!(argv)
+  options = {
+    mode: :staged,
+    format: :text,
+    include_body: true,
+    repo_dir: '.',
+    type: nil,
+    scope: nil,
+    subject: nil,
+    detect_breaking: true
+  }
+
+  parser = OptionParser.new do |opts|
+    opts.banner = 'Usage: kk-git commit-message [options]'
+    opts.on('--repo DIR', 'Git repo directory (default: current dir)') { |v| options[:repo_dir] = v }
+    opts.on('--staged', 'Use staged changes only (default)') { options[:mode] = :staged }
+    opts.on('--worktree', 'Use working-tree changes only (includes untracked)') { options[:mode] = :worktree }
+    opts.on('--all', 'Combine staged + working-tree changes') { options[:mode] = :all }
+    opts.on('--[no-]body', 'Include body for multi-file changes (default: yes)') { |v| options[:include_body] = v }
+    opts.on('--type TYPE', 'Override inferred type') { |v| options[:type] = v }
+    opts.on('--scope SCOPE', 'Override inferred scope') { |v| options[:scope] = v }
+    opts.on('--subject SUBJECT', 'Override inferred subject') { |v| options[:subject] = v }
+    opts.on('--[no-]detect-breaking', 'Detect BREAKING markers (default: yes)') { |v| options[:detect_breaking] = v }
+    opts.on('--format FORMAT', 'Output format: text/json (default: text)') { |v| options[:format] = v.to_s.downcase.to_sym }
+    opts.on('-h', '--help', 'Show help') { puts opts; exit 0 }
+  end
+  parser.parse!(argv)
+
+  options[:type] = to_utf8(options[:type])
+  options[:scope] = to_utf8(options[:scope])
+  options[:subject] = to_utf8(options[:subject])
+
+  result =
+    if options[:format] == :json
+      KKGit::CommitMessage.generate_hash(
+        repo_dir: options[:repo_dir],
+        mode: options[:mode],
+        include_body: options[:include_body],
+        type_override: options[:type],
+        scope_override: options[:scope],
+        subject_override: options[:subject],
+        detect_breaking: options[:detect_breaking]
+      )
+    else
+      KKGit::CommitMessage.generate(
+        repo_dir: options[:repo_dir],
+        mode: options[:mode],
+        include_body: options[:include_body],
+        type_override: options[:type],
+        scope_override: options[:scope],
+        subject_override: options[:subject],
+        detect_breaking: options[:detect_breaking]
+      )
+    end
+
+  if result.nil? || (result.is_a?(Hash) && result[:empty])
+    exit 1
   end
 
-  opts.on('-h', '--help', 'Show help') do
-    puts opts
-    exit 0
+  puts(options[:format] == :json ? JSON.pretty_generate(result) : result)
+end
+
+def run_status!(argv)
+  options = { format: :text }
+  parser = OptionParser.new do |opts|
+    opts.banner = 'Usage: kk-git status [options]'
+    opts.on('--format FORMAT', 'Output format: text/json (default: text)') { |v| options[:format] = v.to_s.downcase.to_sym }
+    opts.on('-h', '--help', 'Show help') { puts opts; exit 0 }
   end
+  parser.parse!(argv)
 
-  opts.on('-v', '--version', 'Show version') do
-    puts KKGit::VERSION
-    exit 0
+  hash = KKGit::GitOps.status_hash
+  if options[:format] == :json
+    puts JSON.pretty_generate(hash)
+  else
+    puts "Branch: #{hash[:branch]} (#{hash[:remote]})"
+    puts "Working tree: #{hash[:clean] ? 'clean' : 'dirty'}"
+    puts "Ahead: #{hash[:ahead]}, Behind: #{hash[:behind]}"
+    puts "Upstream: #{hash[:upstream_configured] ? 'configured' : 'not set'}"
+    puts 'Detached HEAD: yes' if hash[:detached]
   end
 end
 
-# Support `kk-git --version` without subcommand
-if ['--version', '-v'].include?(ARGV[0])
-  puts KKGit::VERSION
-  exit 0
-end
+def run_sync!(argv)
+  parser = OptionParser.new do |opts|
+    opts.banner = 'Usage: kk-git sync [options]'
+    opts.on('-h', '--help', 'Show help') { puts opts; exit 0 }
+  end
+  parser.parse!(argv)
 
-# Support `kk-git --help` without subcommand
-if ['--help', '-h'].include?(ARGV[0])
-  puts parser
-  exit 0
-end
+  remote = KKGit::GitOps.remote
+  branch = KKGit::GitOps.branch
+  s = KKGit::GitOps.status(remote: remote, branch: branch)
 
-subcommand = ARGV.shift
-if subcommand != 'commit-message'
-  warn "Unknown command: #{subcommand}\n\n#{parser}"
-  exit 2
+  if s.needs_sync?
+    KKGit::GitOps.sync_with_remote!(remote, branch)
+  else
+    puts 'Already in sync with remote'
+  end
 end
 
-parser.parse!(ARGV)
+def run_push!(argv)
+  parser = OptionParser.new do |opts|
+    opts.banner = 'Usage: kk-git push [options]'
+    opts.on('-h', '--help', 'Show help') { puts opts; exit 0 }
+  end
+  parser.parse!(argv)
 
-def to_utf8(str)
-  return nil if str.nil?
-  s = str.to_s.dup
-  # In some locales ARGV may be tagged as ASCII-8BIT/US-ASCII, but bytes are usually UTF-8.
-  # Prefer interpreting bytes as UTF-8 and scrub invalid sequences.
-  s.force_encoding(Encoding::UTF_8)
-  s.scrub('�')
+  KKGit::GitOps.auto_commit_push!
 end
 
-options[:type] = to_utf8(options[:type])
-options[:scope] = to_utf8(options[:scope])
-options[:subject] = to_utf8(options[:subject])
-
-result =
-  if options[:format] == :json
-    KKGit::CommitMessage.generate_hash(
-      repo_dir: options[:repo_dir],
-      mode: options[:mode],
-      include_body: options[:include_body],
-      type_override: options[:type],
-      scope_override: options[:scope],
-      subject_override: options[:subject],
-      detect_breaking: options[:detect_breaking]
-    )
-  else
-    KKGit::CommitMessage.generate(
-      repo_dir: options[:repo_dir],
-      mode: options[:mode],
-      include_body: options[:include_body],
-      type_override: options[:type],
-      scope_override: options[:scope],
-      subject_override: options[:subject],
-      detect_breaking: options[:detect_breaking]
-    )
-  end
+def main_help
+  <<~HELP
+    Usage:
+      kk-git --version
+      kk-git commit-message [options]
+      kk-git status [options]
+      kk-git sync [options]
+      kk-git push [options]
+
+    Git helper: generate Conventional Commits messages and automate sync.
+
+    Environment variables (push/sync):
+      KK_GIT_REMOTE       remote name (default: origin)
+      KK_GIT_BRANCH       branch name (default: current branch)
+      KK_GIT_PULL_ARGS    extra args for git pull (default: --ff-only)
+      KK_GIT_ADD_PATHS    paths for git add (default: .)
+      KK_GIT_DRY_RUN=1    print commands without executing
+      KK_GIT_SKIP_PULL=1  skip pull step
+      KK_GIT_SKIP_PUSH=1  skip push step
+      KK_GIT_AMEND=1      amend last commit instead of creating new one
+
+    Run `kk-git <command> --help` for command-specific options.
+  HELP
+end
 
-if result.nil? || (result.is_a?(Hash) && result[:empty])
-  exit 1
+if ['--version', '-v'].include?(ARGV[0])
+  puts KKGit::VERSION
+  exit 0
 end
 
-puts(options[:format] == :json ? JSON.pretty_generate(result) : result)
+if ['--help', '-h'].include?(ARGV[0]) && ARGV.length == 1
+  puts main_help
+  exit 0
+end
 
+subcommand = ARGV.shift
+case subcommand
+when 'commit-message'
+  run_commit_message!(ARGV)
+when 'status'
+  run_status!(ARGV)
+when 'sync'
+  run_sync!(ARGV)
+when 'push'
+  run_push!(ARGV)
+when nil
+  warn "Missing command.\n\n#{main_help}"
+  exit 2
+else
+  warn "Unknown command: #{subcommand}\n\n#{main_help}"
+  exit 2
+end

data/lib/kk/git/git_ops.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'tempfile'
+
+module KKGit
+  # Git 仓库操作：供 Rake task 与 CLI 复用。
+  module GitOps
+    class Error < StandardError; end
+
+    # 仓库同步状态快照
+    Status = Struct.new(
+      :branch, :remote, :clean, :ahead, :behind,
+      :upstream_configured, :detached,
+      keyword_init: true
+    ) do
+      # 是否需要与远端同步（有未推送 commit 或落后远端）
+      def needs_sync?
+        ahead.positive? || behind.positive?
+      end
+
+      def unpushed?
+        ahead.positive?
+      end
+
+      def behind_remote?
+        behind.positive?
+      end
+    end
+
+    class << self
+      # @return [Boolean] KK_GIT_DRY_RUN=1 时只打印命令不执行
+      def dry_run?
+        ENV['KK_GIT_DRY_RUN'] == '1'
+      end
+
+      def skip_pull?
+        ENV['KK_GIT_SKIP_PULL'] == '1'
+      end
+
+      def skip_push?
+        ENV['KK_GIT_SKIP_PUSH'] == '1'
+      end
+
+      def amend?
+        ENV['KK_GIT_AMEND'] == '1'
+      end
+
+      def remote
+        ENV.fetch('KK_GIT_REMOTE', 'origin')
+      end
+
+      # @param explicit [String, nil] KK_GIT_BRANCH 或显式传入
+      def branch(explicit: ENV['KK_GIT_BRANCH'])
+        explicit.to_s.strip.empty? ? current_branch : explicit.to_s.strip
+      end
+
+      # git add 路径，默认 `.`；可用 KK_GIT_ADD_PATHS 指定多个路径（空格分隔）
+      def add_paths
+        ENV.fetch('KK_GIT_ADD_PATHS', '.').split(/\s+/).reject(&:empty?)
+      end
+
+      # 会修改仓库状态的 git 子命令；dry-run 时跳过这些命令
+      MUTATING_GIT_COMMANDS = %w[add commit push pull merge rebase checkout reset cherry-pick revert].freeze
+
+      def run_cmd(*cmd, chdir: nil)
+        if dry_run? && mutating_git_command?(cmd)
+          label = chdir ? "(cd #{chdir} && #{cmd.join(' ')})" : cmd.join(' ')
+          puts "[dry-run] #{label}"
+          return ['', '', true]
+        end
+
+        stdout, stderr, status =
+          if chdir
+            Open3.capture3(*cmd, chdir: chdir)
+          else
+            Open3.capture3(*cmd)
+          end
+        [stdout.to_s, stderr.to_s, status.success?]
+      end
+
+      def mutating_git_command?(cmd)
+        cmd[0] == 'git' && MUTATING_GIT_COMMANDS.include?(cmd[1])
+      end
+
+      def ensure_ok!(ok, title, stdout: nil, stderr: nil)
+        return if ok
+
+        msg = +"#{title} failed"
+        msg << "\n#{stderr}" unless stderr.to_s.strip.empty?
+        msg << "\n#{stdout}" unless stdout.to_s.strip.empty?
+        raise Error, msg
+      end
+
+      def in_git_repo?
+        _, _, ok = run_cmd('git', 'rev-parse', '--git-dir')
+        ok
+      end
+
+      def ensure_in_repo!
+        raise Error, 'Not a git repository' unless in_git_repo?
+      end
+
+      def current_branch
+        out, err, ok = run_cmd('git', 'rev-parse', '--abbrev-ref', 'HEAD')
+        ensure_ok!(ok, 'Get current branch', stdout: out, stderr: err)
+        out.strip
+      end
+
+      def detached_head?
+        current_branch == 'HEAD'
+      end
+
+      def ensure_not_detached!
+        raise Error, 'Cannot push from detached HEAD' if detached_head?
+      end
+
+      def working_tree_clean?
+        out, err, ok = run_cmd('git', 'status', '--porcelain')
+        ensure_ok!(ok, 'Check git status', stdout: out, stderr: err)
+        out.strip.empty?
+      end
+
+      def upstream_configured?
+        _, _, ok = run_cmd('git', 'rev-parse', '--abbrev-ref', '@{u}')
+        ok
+      end
+
+      # 相对 upstream / remote/branch 领先的 commit 数
+      def ahead_count(remote, branch)
+        out, _err, ok = run_cmd('git', 'rev-list', '--count', '@{u}..HEAD')
+        return out.strip.to_i if ok
+
+        out, _err, ok = run_cmd('git', 'rev-list', '--count', "#{remote}/#{branch}..HEAD")
+        return out.strip.to_i if ok
+
+        0
+      end
+
+      # 相对 upstream / remote/branch 落后的 commit 数
+      def behind_count(remote, branch)
+        out, _err, ok = run_cmd('git', 'rev-list', '--count', 'HEAD..@{u}')
+        return out.strip.to_i if ok
+
+        out, _err, ok = run_cmd('git', 'rev-list', '--count', "HEAD..#{remote}/#{branch}")
+        return out.strip.to_i if ok
+
+        0
+      end
+
+      def unpushed_commits?(remote, branch)
+        ahead_count(remote, branch).positive?
+      end
+
+      # @return [Status]
+      def status(remote: nil, branch: nil)
+        ensure_in_repo!
+        remote ||= self.remote
+        branch ||= self.branch
+
+        Status.new(
+          branch: branch,
+          remote: remote,
+          clean: working_tree_clean?,
+          ahead: ahead_count(remote, branch),
+          behind: behind_count(remote, branch),
+          upstream_configured: upstream_configured?,
+          detached: detached_head?
+        )
+      end
+
+      def status_hash(remote: nil, branch: nil)
+        s = status(remote: remote, branch: branch)
+        {
+          branch: s.branch,
+          remote: s.remote,
+          clean: s.clean,
+          ahead: s.ahead,
+          behind: s.behind,
+          upstream_configured: s.upstream_configured,
+          detached: s.detached,
+          needs_sync: s.needs_sync?
+        }
+      end
+
+      def pull_remote!(remote, branch)
+        return if skip_pull?
+
+        pull_args = ENV.fetch('KK_GIT_PULL_ARGS', '--ff-only').split
+        out, err, ok = run_cmd('git', 'pull', remote, branch, *pull_args)
+        ensure_ok!(ok, 'git pull', stdout: out, stderr: err)
+      end
+
+      def push_remote!(remote, branch)
+        return if skip_push?
+
+        ensure_not_detached! unless dry_run?
+
+        if upstream_configured?
+          out, err, ok = run_cmd('git', 'push', remote, branch)
+        else
+          out, err, ok = run_cmd('git', 'push', '-u', remote, branch)
+        end
+        ensure_ok!(ok, 'git push', stdout: out, stderr: err)
+      end
+
+      def sync_with_remote!(remote, branch)
+        pull_remote!(remote, branch)
+        push_remote!(remote, branch)
+        puts "Synced: #{remote} #{branch}" unless dry_run?
+      end
+
+      def add_all!
+        paths = add_paths
+        out, err, ok = run_cmd('git', 'add', *paths)
+        ensure_ok!(ok, 'git add', stdout: out, stderr: err)
+      end
+
+      # @return [Boolean] commit 是否成功
+      def commit_with_message!(message)
+        commit_args = amend? ? %w[commit --amend -F] : %w[commit -F]
+
+        Tempfile.create('commit_message') do |f|
+          f.write(message)
+          f.flush
+          out, err, ok = run_cmd('git', *commit_args, f.path)
+          if ok
+            true
+          elsif err.include?('nothing to commit') || out.include?('nothing to commit')
+            puts 'No staged changes to commit'
+            false
+          else
+            ensure_ok!(ok, 'git commit', stdout: out, stderr: err)
+            false
+          end
+        end
+      end
+
+      # 自动 add → commit → pull → push 主流程
+      #
+      # @return [Symbol] :synced | :committed_and_synced | :noop
+      def auto_commit_push!(commit_message_generator: nil)
+        ensure_in_repo!
+        remote_name = remote
+        branch_name = branch
+
+        if working_tree_clean?
+          if status(remote: remote_name, branch: branch_name).needs_sync?
+            sync_with_remote!(remote_name, branch_name)
+            return :synced
+          end
+
+          puts 'No changes to commit or push'
+          return :noop
+        end
+
+        add_all!
+
+        message =
+          if commit_message_generator
+            commit_message_generator.call
+          else
+            KKGit::CommitMessage.generate(mode: :all)
+          end
+        message = message.to_s.strip
+        message = "chore(repo): update project files\n\n#{Time.now}" if message.empty?
+
+        committed = commit_with_message!(message)
+        if committed || unpushed_commits?(remote_name, branch_name)
+          sync_with_remote!(remote_name, branch_name)
+          return committed ? :committed_and_synced : :synced
+        end
+
+        :noop
+      end
+    end
+  end
+end

data/lib/kk/git/rake_tasks.rb

@@ -2,8 +2,6 @@
 
 require 'rake'
 require_relative '../git'
-require 'open3'
-require 'tempfile'
 
 module KKGit
   # Rake integration: `require 'kk/git/rake_tasks'` to register tasks.
@@ -12,36 +10,33 @@ module KKGit
   # - These tasks do NOT exit/abort so they can be invoked by other tasks.
   # - The generated message is stored in `ENV['KK_GIT_COMMIT_MESSAGE']`.
   module RakeTasks
-    def self.run_cmd(*cmd)
-      stdout, stderr, status = Open3.capture3(*cmd)
-      [stdout.to_s, stderr.to_s, status.success?]
-    end
-
-    def self.ensure_ok!(ok, title, stdout: nil, stderr: nil)
-      return if ok
-
-      msg = +"#{title} failed"
-      msg << "\n#{stderr}" unless stderr.to_s.strip.empty?
-      msg << "\n#{stdout}" unless stdout.to_s.strip.empty?
-      raise msg
-    end
-
-    def self.current_branch
-      out, err, ok = run_cmd('git', 'rev-parse', '--abbrev-ref', 'HEAD')
-      ensure_ok!(ok, 'Get current branch', stdout: out, stderr: err)
-      out.strip
-    end
-
-    def self.working_tree_clean?
-      out, err, ok = run_cmd('git', 'status', '--porcelain')
-      ensure_ok!(ok, 'Check git status', stdout: out, stderr: err)
-      out.strip.empty?
-    end
-
     def self.install!
       extend Rake::DSL
 
       namespace :git do
+        desc 'Show branch sync status (ahead/behind/clean)'
+        task :status do
+          s = KKGit::GitOps.status
+          puts "Branch: #{s.branch} (#{s.remote})"
+          puts "Working tree: #{s.clean ? 'clean' : 'dirty'}"
+          puts "Ahead: #{s.ahead}, Behind: #{s.behind}"
+          puts "Upstream: #{s.upstream_configured ? 'configured' : 'not set'}"
+          puts 'Detached HEAD: yes' if s.detached
+        end
+
+        desc 'Pull and push without committing (sync unpushed or behind commits)'
+        task :sync do
+          remote = KKGit::GitOps.remote
+          branch = KKGit::GitOps.branch
+          s = KKGit::GitOps.status(remote: remote, branch: branch)
+
+          if s.needs_sync?
+            KKGit::GitOps.sync_with_remote!(remote, branch)
+          else
+            puts 'Already in sync with remote'
+          end
+        end
+
         desc 'Generate commit message from staged changes (Conventional Commits)'
         task :commit_message do
           msg = KKGit::CommitMessage.generate(mode: :staged)
@@ -65,49 +60,13 @@ module KKGit
 
         desc 'Auto add/commit/pull/push (uses git:auto_commit)'
         task :auto_commit_push do
-          if working_tree_clean?
-            puts 'No changes to commit'
-            next
+          generator = lambda do
+            Rake::Task['git:auto_commit'].reenable
+            Rake::Task['git:auto_commit'].invoke
+            ENV['KK_GIT_COMMIT_MESSAGE'].to_s
           end
 
-          remote = ENV.fetch('KK_GIT_REMOTE', 'origin')
-          branch = ENV.fetch('KK_GIT_BRANCH', current_branch)
-
-          # 1) add
-          out, err, ok = run_cmd('git', 'add', '.')
-          ensure_ok!(ok, 'git add', stdout: out, stderr: err)
-
-          # 2) generate commit message (allow re-invoke)
-          Rake::Task['git:auto_commit'].reenable
-          Rake::Task['git:auto_commit'].invoke
-          commit_message = ENV['KK_GIT_COMMIT_MESSAGE'].to_s.strip
-          commit_message = "chore(repo): update project files\n\n#{Time.now}" if commit_message.empty?
-
-          # 3) commit (use a tempfile to avoid escaping issues)
-          Tempfile.create('commit_message') do |f|
-            f.write(commit_message)
-            f.flush
-            out, err, ok = run_cmd('git', 'commit', '-F', f.path)
-            # If there are no staged changes, git commit fails; show a friendlier message.
-            unless ok
-              if err.include?('nothing to commit') || out.include?('nothing to commit')
-                puts 'No staged changes to commit'
-                next
-              end
-            end
-            ensure_ok!(ok, 'git commit', stdout: out, stderr: err)
-          end
-
-          # 4) pull (default: --ff-only to avoid interactive merges)
-          pull_args = ENV.fetch('KK_GIT_PULL_ARGS', '--ff-only').split
-          out, err, ok = run_cmd('git', 'pull', *pull_args)
-          ensure_ok!(ok, 'git pull', stdout: out, stderr: err)
-
-          # 5) push
-          out, err, ok = run_cmd('git', 'push', remote, branch)
-          ensure_ok!(ok, 'git push', stdout: out, stderr: err)
-
-          puts "Pushed: #{remote} #{branch}"
+          KKGit::GitOps.auto_commit_push!(commit_message_generator: generator)
         end
       end
     end
@@ -115,4 +74,3 @@ module KKGit
 end
 
 KKGit::RakeTasks.install!
-

data/lib/kk/git/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module KKGit
-  VERSION = '0.1.7'
+  VERSION = '0.2.1'
 end
 

data/lib/kk/git.rb

@@ -2,6 +2,7 @@
 
 require_relative 'git/version'
 require_relative 'git/commit_message'
+require_relative 'git/git_ops'
 
 module KKGit
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kk-git
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.1
 platform: ruby
 authors:
 - kk
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-25 00:00:00.000000000 Z
+date: 2026-06-19 00:00:00.000000000 Z
 dependencies: []
 description: Generate Conventional Commits commit messages from current git changes
   (staged/worktree), designed for Rake/script usage.
@@ -22,6 +22,7 @@ files:
 - exe/kk-git
 - lib/kk/git.rb
 - lib/kk/git/commit_message.rb
+- lib/kk/git/git_ops.rb
 - lib/kk/git/rake_tasks.rb
 - lib/kk/git/version.rb
 homepage: ''