hunkify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 462d60419d0723593916ed35414e3f70ba61df1284f13aeaf640d7d45e0aaed3
+  data.tar.gz: 720035e85d1c6f7b8770a361e0e2a6cde7a98b6e9eeb3e1fffbe95054bfda91f
+SHA512:
+  metadata.gz: 7a51c9e785a105b186221212c7eb5a5111a2da5a58462cb7359bedd8a3312ebb9f34f4f73dfd1ee0e244ffe01f7f772d4501b1439daf772443a0e0b8df445e5e
+  data.tar.gz: 6f0fafc113ff3398179b232a198372e0fcd4249bac99981e5dedf704a638adb3472d58b43f02c7825cfbd95e6d0ba3f33f07dcbe76c042cf8a6a3d47ff769e03

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom SCHIAVI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# hunkify
+
+Split your staged changes into atomic, well-scoped commits — powered by Claude.
+
+Instead of cramming everything into a single `git commit -m "wip"`, `hunkify` parses your staged diff hunk by hunk, asks Claude to group them by intent, and produces conventional commits (with gitmojis) ready to apply.
+
+## Features
+
+- **Hunk-level analysis** — each change block is treated independently, so one file can span multiple commits if needed.
+- **AI-powered grouping** via Claude Haiku 4.5 — fast, cheap, accurate.
+- **Gitmoji + conventional commits** — `:sparkles: feat(scope): …`, `:bug: fix(scope): …`, etc.
+- **Interactive review** — confirm, edit, or skip each proposed commit before it's created.
+- **Free-form context argument** — pass a ticket ID, feature name, or any directive to steer the output.
+- **Safe rollback** — if anything fails mid-run, your original staged state is restored.
+
+## Requirements
+
+- Ruby ≥ 2.7
+- An [Anthropic API key](https://console.anthropic.com/)
+
+## Installation
+
+```bash
+gem install hunkify
+```
+
+Or add to your `Gemfile`:
+
+```ruby
+gem "hunkify"
+```
+
+## Setup
+
+Export your Anthropic API key (add to your `~/.zshrc` or `~/.bashrc`):
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+## Usage
+
+```bash
+git add .
+hunkify
+```
+
+With a context hint (ticket ID, feature name, or any free-form directive):
+
+```bash
+hunkify my_ticket_id
+hunkify "user onboarding"
+hunkify "focus on refactoring"
+```
+
+### Workflow
+
+1. `hunkify` parses your staged diff into hunks.
+2. Claude proposes a grouping into logical commits.
+3. For each proposed commit, you can **confirm**, **edit the message**, **skip**, or **quit**.
+4. After a final confirmation, the plan is applied — each commit is created via `git apply --cached`.
+
+If anything goes wrong during apply, the original staged state is restored.
+
+## Debug
+
+Set `HUNKIFY_DEBUG=1` to print the raw AI response and the patches being applied:
+
+```bash
+HUNKIFY_DEBUG=1 hunkify
+```
+
+## License
+
+MIT

data/bin/hunkify

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/hunkify"
+
+Hunkify::CLI.run(ARGV)

data/lib/hunkify/anthropic_api.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Hunkify
+  module AnthropicAPI
+    API_URL = "https://api.anthropic.com/v1/messages"
+    MODEL = "claude-haiku-4-5-20251001"
+
+    SYSTEM_PROMPT = <<~PROMPT
+      You are a Git expert. You are given a list of hunks (blocks of modifications)
+      extracted from a git diff. Your job is to group them into coherent logical commits.
+
+      GROUPING RULES:
+      - One commit = one unique intent (feat, fix, refactor, style, etc.)
+      - Hunks in different files CAN belong to the same commit if they serve the same intent
+      - Hunks in the SAME file can belong to DIFFERENT commits if they are semantically distinct
+      - Prefer atomic and independent commits
+
+      RESPONSE FORMAT (strict JSON, no surrounding text):
+      {
+        "commits": [
+          {
+            "message": ":sparkles: feat(scope): description in English",
+            "hunk_ids": [1, 3, 5],
+            "reasoning": "brief explanation of the grouping"
+          },
+          {
+            "message": ":bug: fix(scope): description in English",
+            "hunk_ids": [2, 4],
+            "reasoning": "brief explanation"
+          }
+        ]
+      }
+
+      AVAILABLE GITMOJIS:
+      :sparkles: feat | :bug: fix | :recycle: refactor | :lipstick: style
+      :white_check_mark: test | :memo: docs | :wrench: config | :package: build
+      :zap: perf | :lock: security | :fire: remove | :art: format
+      :construction: wip | :card_file_box: db | :green_heart: ci | :rocket: deploy
+
+      MESSAGE RULES:
+      - In English, imperative, no leading capital, no trailing period
+      - Max 72 characters
+      - Scope = module / component / main file concerned
+      - If a user context is provided, use it as a hint to steer scope, wording,
+        or grouping. It may be a ticket ID (include it as the scope, e.g. feat(EA4-370): ...),
+        a feature name, or a free-form directive.
+
+      RESPOND ONLY WITH THE JSON. No markdown, no explanation.
+    PROMPT
+
+    def self.group_hunks(hunks, context: nil)
+      api_key = ENV["ANTHROPIC_API_KEY"]
+      raise "ANTHROPIC_API_KEY missing! Add it to your ~/.zshrc or ~/.bashrc" if api_key.nil? || api_key.empty?
+
+      user_ctx = context && !context.empty? ? "\nUser context: #{context}" : ""
+      hunks_summary = hunks.map(&:to_summary).join("\n\n---\n\n")
+      user_message = "#{user_ctx}\n\nHere are the hunks to group:\n\n#{hunks_summary}"
+
+      uri = URI(API_URL)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.read_timeout = 30
+
+      request = Net::HTTP::Post.new(uri.path)
+      request["Content-Type"] = "application/json"
+      request["x-api-key"] = api_key
+      request["anthropic-version"] = "2023-06-01"
+      request.body = JSON.generate({
+        model: MODEL,
+        max_tokens: 1024,
+        system: SYSTEM_PROMPT,
+        messages: [{role: "user", content: user_message}]
+      })
+
+      response = http.request(request)
+      body = JSON.parse(response.body)
+
+      raise "API Error #{response.code}: #{body["error"]&.dig("message")}" unless response.code == "200"
+
+      raw = body.dig("content", 0, "text")&.strip
+
+      if ENV["HUNKIFY_DEBUG"]
+        warn "\n--- RAW AI RESPONSE ---\n#{raw}\n-----------------------\n"
+      end
+
+      cleaned = raw
+        .gsub(/\A```(?:json)?\s*/i, "")
+        .gsub(/\s*```\z/, "")
+        .strip
+
+      if (match = cleaned.match(/(\{.+\})/m))
+        cleaned = match[1]
+      end
+
+      JSON.parse(cleaned)
+    end
+  end
+end

data/lib/hunkify/cli.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "color"
+require_relative "diff_parser"
+require_relative "git"
+require_relative "anthropic_api"
+require_relative "ui"
+
+module Hunkify
+  module CLI
+    module_function
+
+    def run(argv)
+      context = argv[0]
+
+      UI.print_header
+
+      begin
+        Git.root
+      rescue RuntimeError
+        puts Color.red("  ✗ This directory is not a Git repository.")
+        exit 1
+      end
+
+      unless Git.has_staged_changes?
+        puts Color.yellow("  ⚠️  No staged changes.")
+        puts Color.dim("  Run first: git add <files>")
+        exit 0
+      end
+
+      original_staged_files = Git.staged_files
+
+      puts Color.dim("  Parsing diff...")
+      raw_diff = Git.staged_diff
+      hunks = DiffParser.parse(raw_diff)
+
+      if hunks.empty?
+        puts Color.yellow("  ⚠️  No hunks found in staged diff.")
+        exit 0
+      end
+
+      UI.print_hunks_overview(hunks)
+
+      hunks_by_id = hunks.each_with_object({}) { |h, acc| acc[h.id] = h }
+
+      puts Color.dim("  Analyzing and grouping via Claude #{AnthropicAPI::MODEL}...")
+      puts
+
+      begin
+        result = AnthropicAPI.group_hunks(hunks, context: context)
+      rescue JSON::ParserError
+        puts Color.red("  ✗ Invalid AI response (malformed JSON). Try again.")
+        exit 1
+      rescue RuntimeError => e
+        puts Color.red("  ✗ #{e.message}")
+        exit 1
+      end
+
+      commits_data = result["commits"]
+
+      if commits_data.nil? || commits_data.empty?
+        puts Color.red("  ✗ The AI returned no commits.")
+        exit 1
+      end
+
+      commits_data.each do |c|
+        c["hunk_ids"] = c["hunk_ids"].select { |id| hunks_by_id.key?(id) }
+      end
+      commits_data.reject! { |c| c["hunk_ids"].empty? }
+
+      UI.print_grouping(commits_data, hunks_by_id)
+
+      plan = []
+      commits_data.each_with_index do |c, i|
+        puts Color.bold("  Commit #{i + 1}/#{commits_data.size}:")
+        msg = UI.prompt_edit_commit(c, i + 1, commits_data.size)
+        plan << [msg, c["hunk_ids"]] if msg
+        puts
+      end
+
+      if plan.empty?
+        puts Color.yellow("  No commit selected.")
+        exit 0
+      end
+
+      UI.confirm_plan(plan)
+
+      execute_commits(plan, hunks_by_id, original_staged_files)
+
+      puts
+      puts Color.bold(Color.green("  ✅ #{plan.size} commit(s) successfully created!"))
+      puts
+    end
+
+    def execute_commits(plan, hunks_by_id, original_staged_files)
+      puts
+      total = plan.size
+
+      Git.unstage_all
+
+      plan.each_with_index do |(message, hunk_ids), i|
+        print "  #{Color.dim("Commit #{i + 1}/#{total}...")} "
+
+        hunks_by_file = hunk_ids
+          .map { |id| hunks_by_id[id] }
+          .group_by(&:file_path)
+
+        patch = hunks_by_file.map do |_file_path, file_hunks|
+          first = file_hunks.first
+          hunk_bodies = file_hunks.map do |h|
+            body = h.lines.join("\n")
+            body += "\n" unless body.end_with?("\n")
+            "#{h.hunk_header}\n#{body}"
+          end.join
+          "#{first.file_header}\n#{hunk_bodies}"
+        end.join("\n")
+
+        if ENV["HUNKIFY_DEBUG"]
+          warn "\n--- PATCH ---\n#{patch}\n-------------\n"
+        end
+
+        begin
+          Git.apply_patch_to_index(patch)
+          Git.commit(message)
+          puts Color.green("✓ #{message}")
+        rescue RuntimeError => e
+          puts Color.red("✗ #{e.message}")
+          puts Color.yellow("  ⚠️  Rollback: restaging original files...")
+          Git.unstage_all
+          Git.restage_files(original_staged_files)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/hunkify/color.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hunkify
+  module Color
+    RESET = "\e[0m"
+    BOLD = "\e[1m"
+    DIM = "\e[2m"
+    CYAN = "\e[36m"
+    GREEN = "\e[32m"
+    YELLOW = "\e[33m"
+    RED = "\e[31m"
+    MAGENTA = "\e[35m"
+    BLUE = "\e[34m"
+
+    def self.cyan(s) = "#{CYAN}#{s}#{RESET}"
+    def self.green(s) = "#{GREEN}#{s}#{RESET}"
+    def self.yellow(s) = "#{YELLOW}#{s}#{RESET}"
+    def self.red(s) = "#{RED}#{s}#{RESET}"
+    def self.bold(s) = "#{BOLD}#{s}#{RESET}"
+    def self.dim(s) = "#{DIM}#{s}#{RESET}"
+    def self.magenta(s) = "#{MAGENTA}#{s}#{RESET}"
+    def self.blue(s) = "#{BLUE}#{s}#{RESET}"
+  end
+end

data/lib/hunkify/diff_parser.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "hunk"
+
+module Hunkify
+  module DiffParser
+    def self.parse(raw_diff)
+      hunks = []
+      hunk_id = 0
+      file_header = nil
+      file_path = nil
+      hunk_header = nil
+      hunk_lines = []
+
+      raw_diff.each_line do |line|
+        line = line.chomp
+        line = " " if line.empty? && hunk_header
+
+        if line.start_with?("diff --git")
+          if hunk_header && !hunk_lines.empty?
+            hunk_id += 1
+            hunks << Hunk.new(
+              id: hunk_id,
+              file_header: file_header,
+              file_path: file_path,
+              hunk_header: hunk_header,
+              lines: hunk_lines.dup
+            )
+          end
+          hunk_header = nil
+          hunk_lines = []
+          file_header = line
+          file_path = line.split(" b/").last
+
+        elsif line.start_with?("--- ", "+++ ", "index ", "new file", "deleted file", "old mode", "new mode", "rename ")
+          file_header = "#{file_header}\n#{line}"
+
+        elsif line.start_with?("@@")
+          if hunk_header && !hunk_lines.empty?
+            hunk_id += 1
+            hunks << Hunk.new(
+              id: hunk_id,
+              file_header: file_header,
+              file_path: file_path,
+              hunk_header: hunk_header,
+              lines: hunk_lines.dup
+            )
+          end
+          hunk_header = line
+          hunk_lines = []
+
+        elsif hunk_header
+          hunk_lines << line
+        end
+      end
+
+      if hunk_header && !hunk_lines.empty?
+        hunk_id += 1
+        hunks << Hunk.new(
+          id: hunk_id,
+          file_header: file_header,
+          file_path: file_path,
+          hunk_header: hunk_header,
+          lines: hunk_lines.dup
+        )
+      end
+
+      hunks
+    end
+  end
+end

data/lib/hunkify/git.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+
+module Hunkify
+  module Git
+    def self.run(cmd)
+      stdout, stderr, status = Open3.capture3(cmd)
+      raise "Git error: #{stderr.strip}" unless status.success?
+      stdout.strip
+    end
+
+    def self.staged_diff
+      run("git diff --staged")
+    end
+
+    def self.staged_files
+      run("git diff --staged --name-only").split("\n")
+    end
+
+    def self.has_staged_changes?
+      !staged_files.empty?
+    end
+
+    def self.root
+      run("git rev-parse --show-toplevel")
+    end
+
+    def self.apply_patch_to_index(patch_content)
+      Tempfile.create(["hunkify_patch", ".patch"]) do |f|
+        f.write(patch_content)
+        f.flush
+        stdout, stderr, status = Open3.capture3("git", "apply", "--cached", "--whitespace=nowarn", f.path)
+        raise "Git error: #{stderr.strip}" unless status.success?
+        stdout.strip
+      end
+    end
+
+    def self.unstage_all
+      if head_exists?
+        run("git reset HEAD")
+      else
+        stdout, _stderr, status = Open3.capture3("git", "ls-files", "-z", "--cached")
+        raise "Git error: unable to list index" unless status.success?
+        stdout.split("\0").reject(&:empty?).each do |path|
+          _o, err, st = Open3.capture3("git", "rm", "--cached", "-f", "--", path)
+          raise "Git error: #{err.strip}" unless st.success?
+        end
+      end
+    end
+
+    def self.head_exists?
+      _o, _e, status = Open3.capture3("git", "rev-parse", "--verify", "HEAD")
+      status.success?
+    end
+
+    def self.commit(message)
+      stdout, stderr, status = Open3.capture3("git", "commit", "-m", message)
+      raise "Git error: #{stderr.strip}" unless status.success?
+      stdout.strip
+    end
+
+    def self.restage_files(files)
+      files.each { |f|
+        begin
+          run("git add \"#{f}\"")
+        rescue
+          nil
+        end
+      }
+    end
+  end
+end

data/lib/hunkify/hunk.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Hunkify
+  Hunk = Struct.new(:id, :file_header, :file_path, :hunk_header, :lines, keyword_init: true) do
+    def to_patch
+      body = lines.join("\n")
+      body += "\n" unless body.end_with?("\n")
+      "#{file_header}\n#{hunk_header}\n#{body}"
+    end
+
+    def to_summary
+      added = lines.count { |l| l.start_with?("+") }
+      removed = lines.count { |l| l.start_with?("-") }
+      preview = lines.first(6).join("\n")
+      "[HUNK #{id}] #{file_path} #{hunk_header}\n#{preview}\n(+#{added} / -#{removed} lines)"
+    end
+  end
+end

data/lib/hunkify/ui.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "color"
+
+module Hunkify
+  module UI
+    module_function
+
+    def print_header
+      version = defined?(Hunkify::VERSION) ? Hunkify::VERSION : ""
+      puts
+      puts "  #{Color.magenta("▲")} #{Color.bold("hunkify")} #{Color.dim("v#{version}")}"
+      puts "  #{Color.dim("─" * 40)}"
+      puts "  #{Color.dim("Atomic commits, grouped by Claude.")}"
+      puts
+    end
+
+    def print_hunks_overview(hunks)
+      puts Color.bold("🔍 #{hunks.size} hunk(s) detected:")
+      hunks.each do |h|
+        added = h.lines.count { |l| l.start_with?("+") }
+        removed = h.lines.count { |l| l.start_with?("-") }
+        puts "   #{Color.dim("[#{h.id}]")} #{Color.cyan(h.file_path)}  #{Color.green("+#{added}")} #{Color.red("-#{removed}")}"
+      end
+      puts
+    end
+
+    def print_grouping(commits_data, hunks_by_id)
+      puts Color.bold("🤖 AI-proposed grouping:")
+      puts
+
+      commits_data.each_with_index do |c, i|
+        hunk_list = c["hunk_ids"].map { |id| Color.dim("[#{id}]") }.join(" ")
+        files = c["hunk_ids"].map { |id| hunks_by_id[id]&.file_path }.compact.uniq
+
+        puts "  #{Color.bold(Color.blue("Commit #{i + 1}"))}  #{hunk_list}"
+        puts "  #{Color.green(c["message"])}"
+        puts "  #{Color.dim("↳ " + c["reasoning"])}"
+        puts "  #{Color.dim("Files: " + files.join(", "))}"
+        puts
+      end
+    end
+
+    def prompt_edit_commit(commit_data, _index, _total)
+      print "  #{Color.yellow("[Enter]")} Confirm  #{Color.yellow("[e]")} Edit message  #{Color.yellow("[s]")} Skip  #{Color.yellow("[q]")} Quit: "
+      input = $stdin.gets.chomp.downcase
+
+      case input
+      when ""
+        commit_data["message"]
+      when "e"
+        print "  ✏️  New message: "
+        new_msg = $stdin.gets.chomp
+        new_msg.empty? ? commit_data["message"] : new_msg
+      when "s"
+        nil
+      when "q"
+        puts Color.red("\n  Cancelled.")
+        exit 0
+      else
+        commit_data["message"]
+      end
+    end
+
+    def confirm_plan(plan)
+      puts Color.bold("📋 Final plan:")
+      plan.each_with_index do |(msg, _), i|
+        puts "   #{Color.dim("#{i + 1}.")} #{Color.green(msg)}"
+      end
+      puts
+      print "  #{Color.yellow("[Enter]")} Run  #{Color.yellow("[q]")} Cancel: "
+      input = $stdin.gets.chomp.downcase
+      exit 0 if input == "q"
+    end
+  end
+end

data/lib/hunkify/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hunkify
+  VERSION = "0.1.0"
+end

data/lib/hunkify.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "hunkify/version"
+require_relative "hunkify/color"
+require_relative "hunkify/hunk"
+require_relative "hunkify/diff_parser"
+require_relative "hunkify/git"
+require_relative "hunkify/anthropic_api"
+require_relative "hunkify/ui"
+require_relative "hunkify/cli"
+
+module Hunkify
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: hunkify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom SCHIAVI
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: hunkify analyzes staged hunks, asks Claude to group them into logical
+  commits, and applies them via git apply --cached.
+executables:
+- hunkify
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/hunkify
+- lib/hunkify.rb
+- lib/hunkify/anthropic_api.rb
+- lib/hunkify/cli.rb
+- lib/hunkify/color.rb
+- lib/hunkify/diff_parser.rb
+- lib/hunkify/git.rb
+- lib/hunkify/hunk.rb
+- lib/hunkify/ui.rb
+- lib/hunkify/version.rb
+homepage: https://github.com/tomschiavi/smartcommit
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/tomschiavi/smartcommit
+  bug_tracker_uri: https://github.com/tomschiavi/smartcommit/issues
+  changelog_uri: https://github.com/tomschiavi/smartcommit/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Split staged changes into atomic commits using Claude.
+test_files: []