changelog-builder 1.0.0

data/lib/changelogger/changelog_generator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Changelogger
+  # Changelog generator.
+  class ChangelogGenerator
+    class << self
+      # +Changelogger::ChangelogGenerator.build_sections+                      -> String
+      #
+      # Build sections from versioned commits.
+      #
+      # @param [Array<(Integer, Changelogger::Commit, String)>] versioned
+      # @return [String]
+      def build_sections(versioned)
+        versioned.map do |(_i, c, v)|
+          lines = []
+          lines << "## [#{v}] - #{c.date}"
+          lines << ""
+          lines << "- #{c.subject} (#{c.short})"
+          c.body.split("\n").each { |b| lines << "  #{b}" } unless c.body.nil? || c.body.empty?
+          lines << ""
+          lines.join("\n")
+        end.join("\n")
+      end
+
+      # +Changelogger::ChangelogGenerator.render+                              -> String
+      #
+      # Render the changelog content.
+      #
+      # @param [Array<Changelogger::Commit>] commits
+      # @param [Array<String>] anchor_shas
+      # @param [Integer] major
+      # @param [Integer] minor_start
+      # @param [Integer] base_patch
+      # @return [String]
+      def render(commits, anchor_shas, major: 0, minor_start: 1, base_patch: 10)
+        sha_to_idx = commits.map(&:sha)
+        short_to_idx = commits.map(&:short)
+
+        anchor_indices = anchor_shas.filter_map do |sha|
+          full_idx = sha_to_idx.index(sha)
+          full_idx || short_to_idx.index(sha[0, 7])
+        end
+        raise "Need at least 2 valid commits selected" if anchor_indices.size < 2
+
+        versioned = Versioner.assign(commits, anchor_indices, major: major, minor_start: minor_start,
+                                                              base_patch: base_patch)
+        header = "## [Unreleased]\n\n"
+        sections = build_sections(versioned)
+        [header, sections].join("\n")
+      end
+
+      # +Changelogger::ChangelogGenerator.generate+                            -> String
+      #
+      # Generate the changelog file.
+      #
+      # @param [Array<Changelogger::Commit>] commits
+      # @param [Array<String>] anchor_shas
+      # @param [String] path
+      # @param [Integer] major
+      # @param [Integer] minor_start
+      # @param [Integer] base_patch
+      # @return [String] path
+      def generate(commits, anchor_shas, path: "CHANGELOG.md", major: 0, minor_start: 1, base_patch: 10)
+        content = render(commits, anchor_shas, major: major, minor_start: minor_start, base_patch: base_patch)
+        File.write(path, content)
+        path
+      end
+    end
+  end
+end

data/lib/changelogger/cli.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "tmpdir"
+require "fileutils"
+
+require_relative "version"
+require_relative "git"
+require_relative "changelog_generator"
+
+module Changelogger
+  # +Changelogger::CLI+ provides both TUI and non-interactive CLI entrypoints.
+  class CLI
+    # +Changelogger::CLI.start+                     -> Integer
+    #
+    # Parses CLI arguments and runs either interactive TUI or headless generation.
+    # Returns an exit code (0 on success).
+    #
+    # @param [Array<String>] argv command line arguments (default: ARGV)
+    # @return [Integer] exit status code
+    def self.start(argv = ARGV)
+      new.start(argv)
+    end
+
+    # +Changelogger::CLI#start+                     -> Integer
+    #
+    # @param [Array<String>] argv
+    # @return [Integer] exit code
+    def start(argv)
+      mode         = :tui
+      anchors      = []
+      output       = "CHANGELOG.md"
+      dry_run      = false
+      major        = 0
+      minor_start  = 1
+      base_patch   = 10
+
+      parser = OptionParser.new do |o|
+        o.banner = "Usage: changelogger [options] [REPO]"
+        o.separator ""
+        o.separator "REPO can be:"
+        o.separator "  - local path (/path/to/repo)"
+        o.separator "  - GitHub slug (owner/repo)"
+        o.separator "  - git URL (https://... or git@...)"
+        o.separator ""
+        o.on("-g", "--generate", "Non-interactive: generate CHANGELOG from anchors") { mode = :generate }
+        o.on("-a", "--anchors x,y,z", Array, "Anchors (SHA/tag/branch), 2+ required in chronological order") do |v|
+          anchors = v || []
+        end
+        o.on("-o", "--output PATH", "Output file (default: CHANGELOG.md)") { |v| output = v }
+        o.on("--major N", Integer, "Major version (default: 0)") { |v| major = v }
+        o.on("--minor-start N", Integer, "Minor start index (default: 1)") { |v| minor_start = v }
+        o.on("--base-patch N", Integer, "Patch spacing base (default: 10)") { |v| base_patch = v }
+        o.on("--dry-run", "Print to stdout (do not write file)") { dry_run = true }
+        o.on("--tui", "Force interactive TUI (default if no --generate)") { mode = :tui }
+        o.on("-v", "--version", "Print version") do
+          puts Changelogger::VERSION
+          return 0
+        end
+        o.on("-h", "--help", "Show help") do
+          puts o
+          return 0
+        end
+      end
+
+      repo_spec = nil
+      begin
+        parser.order!(argv) { |arg| repo_spec ||= arg }
+      rescue OptionParser::ParseError => e
+        warn e.message
+        warn parser
+        return 2
+      end
+
+      with_repo(repo_spec) do
+        case mode
+        when :generate
+          return run_generate(anchors, output, dry_run, major, minor_start, base_patch)
+        else
+          return run_tui(output, major, minor_start, base_patch)
+        end
+      end
+    end
+
+    private
+
+    # +Changelogger::CLI#run_tui+                   -> Integer
+    #
+    # Launches TUI and writes the CHANGELOG if the user selected 2+ anchors.
+    # @param [String] output output path
+    # @param [Integer] major
+    # @param [Integer] minor_start
+    # @param [Integer] base_patch
+    # @return [Integer] exit code
+    def run_tui(output, major, minor_start, base_patch)
+      require_relative "tui"
+      selected = Changelogger::TUI.run
+      return 0 if selected.nil? # cancelled
+
+      if selected.size >= 2
+        commits = Changelogger::Git.commits
+        path = Changelogger::ChangelogGenerator.generate(
+          commits,
+          selected,
+          path: output,
+          major: major,
+          minor_start: minor_start,
+          base_patch: base_patch
+        )
+        puts "Wrote #{path} ✅"
+        0
+      else
+        puts "No CHANGELOG generated (need at least 2 commits)."
+        1
+      end
+    end
+
+    # +Changelogger::CLI#run_generate+              -> Integer
+    #
+    # Headless mode: resolves anchors, renders or writes the CHANGELOG.
+    # @param [Array<String>] anchor_tokens tokens (sha/tag/branch)
+    # @param [String] output path
+    # @param [Boolean] dry_run if true, print to stdout
+    # @param [Integer] major
+    # @param [Integer] minor_start
+    # @param [Integer] base_patch
+    # @return [Integer] exit code
+    def run_generate(anchor_tokens, output, dry_run, major, minor_start, base_patch)
+      if anchor_tokens.size < 2
+        warn "Error: --generate requires at least 2 --anchors (SHA/tag/branch)."
+        return 2
+      end
+
+      resolved = anchor_tokens.filter_map { |t| resolve_commit(t) }
+      if resolved.size < 2
+        warn "Error: could not resolve at least two anchors: #{anchor_tokens.inspect}"
+        return 2
+      end
+
+      commits = Changelogger::Git.commits
+      if dry_run
+        puts Changelogger::ChangelogGenerator.render(
+          commits,
+          resolved,
+          major: major,
+          minor_start: minor_start,
+          base_patch: base_patch
+        )
+      else
+        path = Changelogger::ChangelogGenerator.generate(
+          commits,
+          resolved,
+          path: output,
+          major: major,
+          minor_start: minor_start,
+          base_patch: base_patch
+        )
+        puts "Wrote #{path} ✅"
+      end
+      0
+    end
+
+    # ---------- repo resolution ----------
+
+    # +Changelogger::CLI#with_repo+                 -> Integer
+    #
+    # Changes directory into a target repo (path/slug/url) for the duration of the block.
+    # Clones remotes into a temporary directory and cleans it up afterwards.
+    #
+    # @param [String, nil] repo_spec path, GitHub slug (owner/repo), or git URL
+    # @yield [] block to execute inside the repo
+    # @return [Integer] 0
+    def with_repo(repo_spec)
+      orig_dir = Dir.pwd
+      tmp_dir = nil
+
+      if repo_spec && !repo_spec.empty?
+        if File.directory?(repo_spec)
+          Dir.chdir(File.expand_path(repo_spec))
+          unless inside_git_repo?
+            warn "#{repo_spec.inspect} is not a git repository. Continuing, but output may be empty."
+          end
+        else
+          url = looks_like_url?(repo_spec) ? repo_spec : github_slug_to_url(repo_spec)
+          if url
+            tmp_dir = Dir.mktmpdir("changelogger-")
+            clone_ok = system("git", "clone", "--no-checkout", "--filter=blob:none", "--depth=1000", url, tmp_dir,
+                              out: File::NULL, err: File::NULL)
+            clone_ok ||= system("git", "clone", url, tmp_dir)
+            if clone_ok
+              Dir.chdir(tmp_dir)
+            else
+              warn "Failed to clone #{url}. Running in current directory."
+            end
+          else
+            warn "Unrecognized repo argument: #{repo_spec.inspect}. Expected a directory, GitHub slug (owner/repo), or git URL."
+          end
+        end
+      end
+
+      yield
+      0
+    ensure
+      begin
+        Dir.chdir(orig_dir)
+      rescue StandardError
+        nil
+      end
+      FileUtils.remove_entry(tmp_dir) if tmp_dir && File.directory?(tmp_dir)
+    end
+
+    # +Changelogger::CLI#inside_git_repo?+          -> Bool
+    # @return [Bool] true if inside a git work tree
+    def inside_git_repo?
+      system("git", "rev-parse", "--is-inside-work-tree", out: File::NULL, err: File::NULL)
+    end
+
+    # +Changelogger::CLI#looks_like_url?+           -> Bool
+    # @param [String] s
+    # @return [Bool]
+    def looks_like_url?(s)
+      s =~ %r{\Ahttps?://} || s.start_with?("git@")
+    end
+
+    # +Changelogger::CLI#github_slug_to_url+        -> String, nil
+    # Converts "owner/repo" or "github.com/owner/repo" into an https URL.
+    # @param [String] s
+    # @return [String, nil]
+    def github_slug_to_url(s)
+      if s =~ %r{\Ahttps?://(?:www\.)?github\.com/([\w.-]+/[\w.-]+)(?:\.git)?\z}i
+        "https://github.com/#{::Regexp.last_match(1)}.git"
+      elsif s =~ %r{\A(?:github\.com/)?([\w.-]+/[\w.-]+)(?:\.git)?\z}i
+        "https://github.com/#{::Regexp.last_match(1)}.git"
+      end
+    end
+
+    # +Changelogger::CLI#resolve_commit+            -> String, nil
+    #
+    # Resolves a token (sha/tag/branch) to a 40-char commit SHA.
+    # @param [String] token
+    # @return [String, nil]
+    def resolve_commit(token)
+      full = `git rev-parse -q --verify #{token}^{commit} 2>/dev/null`.strip
+      $CHILD_STATUS.success? && full.match?(/\A[0-9a-f]{40}\z/i) ? full : nil
+    end
+  end
+end

data/lib/changelogger/git.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Changelogger
+  # +Changelogger::Commit+ is a plain struct representing a git commit.
+  #
+  # @!attribute [rw] sha
+  #   @return [String] Full 40-char SHA
+  # @!attribute [rw] short
+  #   @return [String] Abbreviated SHA
+  # @!attribute [rw] date
+  #   @return [String] Commit date (YYYY-MM-DD)
+  # @!attribute [rw] subject
+  #   @return [String] First line message
+  # @!attribute [rw] body
+  #   @return [String] Remaining message body (could be empty)
+  Commit = Struct.new(:sha, :short, :date, :subject, :body, keyword_init: true)
+
+  # +Changelogger::Git+ wraps read-only git queries used by this gem.
+  class Git
+    # Separator used for pretty-format parsing
+    SEP = "\x01"
+
+    # +Changelogger::Git.commits+                     -> Array<Changelogger::Commit>
+    #
+    # Returns repository commits in chronological order (oldest-first).
+    # Uses: git log --date=short --reverse --pretty=format:'...'
+    #
+    # @return [Array<Commit>]
+    def self.commits # rubocop:disable Metrics/MethodLength]
+      format = "%H#{SEP}%h#{SEP}%ad#{SEP}%s#{SEP}%b"
+      cmd = "git log --date=short --reverse --pretty=format:'#{format}'"
+      out = `#{cmd}`
+      out.split("\n").map do |line|
+        sha, short, date, subject, body = line.split(SEP, 5)
+        Commit.new(
+          sha: sha,
+          short: short,
+          date: date,
+          subject: (subject || "").strip,
+          body: (body || "").strip
+        )
+      end
+    end
+  end
+end

data/lib/changelogger/header.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Changelogger
+  # +Changelogger::Header+ draws the top header (title/version) of the TUI.
+  class Header
+    # +Changelogger::Header.new+                    -> Changelogger::Header
+    #
+    # Draws a single header line with the gem name and version.
+    #
+    # @param [Integer] height window height
+    # @param [Integer] width window width
+    # @param [Integer] top top position
+    # @param [Integer] left left position
+    # @return [Header]
+    def initialize(height: 0, width: Curses.cols, top: 0, left: 0)
+      @height = height
+      @width = width
+      @top = top
+      @left = left
+      header_win
+      line
+    end
+
+    private
+
+    # +Changelogger::Header.header_win+             -> void
+    # @private
+    # Initializes the header frame.
+    # @return [void]
+    def header_win
+      @header_win = Curses::Window.new(@height, @width, @top, @left)
+      @header_win.box(" ", " ", " ")
+    end
+
+    # +Changelogger::Header.line+                   -> void
+    # @private
+    # Renders the header text.
+    # @return [void]
+    def line
+      line = @header_win.subwin(@height, @width, @top, @left)
+      line.addstr(" Changelogger #{Changelogger::VERSION} ".center(@width, "="))
+      line.refresh
+    end
+  end
+end

data/lib/changelogger/main.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: false
+
+require "curses"
+require_relative "header"
+require_relative "branches_window"
+require_relative "git"
+require_relative "versioner"
+require_relative "changelog_generator"
+require_relative "preview_window"
+
+Curses.init_screen
+Curses.cbreak
+Curses.curs_set(0)
+Curses.noecho
+
+Changelogger::Header.new
+
+win = Changelogger::BranchWindow.new
+selected = win.select_commits # closes screen on exit
+
+if selected.nil?
+  # ESC/q
+elsif selected.size >= 2
+  commits = Changelogger::Git.commits
+  path = Changelogger::ChangelogGenerator.generate(commits, selected, path: "CHANGELOG.md")
+  puts "Wrote #{path} ✅"
+else
+  puts "No CHANGELOG generated (need at least 2 commits)."
+end

data/lib/changelogger/preview_window.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "curses"
+
+module Changelogger
+  # +Changelogger::PreviewWindow+ shows scrollable text in a framed window.
+  class PreviewWindow
+    # +Changelogger::PreviewWindow.new+                 -> PreviewWindow
+    #
+    # @param [String] title window title
+    # @param [String] content initial text
+    # @param [Integer] top top row position
+    # @param [Integer] left left column position
+    # @param [Integer, nil] height window height or computed from screen
+    # @param [Integer, nil] width window width or computed from screen
+    def initialize(title: "Preview", content: "", top: 1, left: 0, height: nil, width: nil)
+      @title = title
+      screen_h = Curses.lines
+      screen_w = Curses.cols
+
+      @height = height || [screen_h - top, 3].max
+      @width  = width  || [screen_w - left, 10].max
+      @top    = top
+      @left   = left
+
+      @sub_height = @height - 2
+      @sub_width  = @width  - 2
+      @sub_top    = @top + 1
+      @sub_left   = @left + 1
+
+      @offset = 0
+      @lines  = (content || "").split("\n")
+
+      build_windows
+      redraw
+    end
+
+    # +Changelogger::PreviewWindow#update_content+      -> void
+    #
+    # Replace content and reset scroll to top.
+    # @param [String] text new content
+    # @return [void]
+    def update_content(text)
+      @lines  = (text || "").split("\n")
+      @offset = 0
+      redraw
+    end
+
+    # +Changelogger::PreviewWindow#run+                 -> void
+    #
+    # Enters the input loop. Returns when user closes the preview.
+    # @return [void]
+    def run
+      loop do
+        case @sub.getch
+        when Curses::Key::UP, "k"
+          @offset = [@offset - 1, 0].max
+          redraw
+        when Curses::Key::DOWN, "j"
+          max_off = [@lines.length - @sub_height, 0].max
+          @offset = [@offset + 1, max_off].min
+          redraw
+        when Curses::Key::PPAGE
+          @offset = [@offset - @sub_height, 0].max
+          redraw
+        when Curses::Key::NPAGE
+          max_off = [@lines.length - @sub_height, 0].max
+          @offset = [@offset + @sub_height, max_off].min
+          redraw
+        when "g"
+          @offset = 0
+          redraw
+        when "G"
+          @offset = [@lines.length - @sub_height, 0].max
+          redraw
+        when "q", 27
+          break
+        end
+      end
+    ensure
+      destroy
+    end
+
+    private
+
+    # @!visibility private
+
+    def build_windows
+      @frame = Curses::Window.new(@height, @width, @top, @left)
+      @frame.box
+      draw_title
+      @frame.refresh
+
+      @sub = @frame.subwin(@sub_height, @sub_width, @sub_top, @sub_left)
+      @sub.keypad(true)
+      @sub.scrollok(false)
+    end
+
+    def draw_title
+      title = " #{@title} "
+      bar = title.center(@width - 2, "─")
+      @frame.setpos(0, 1)
+      @frame.addstr(bar[0, @width - 2])
+    end
+
+    def redraw
+      @sub.erase
+
+      visible = @lines[@offset, @sub_height] || []
+      visible.each_with_index do |line, i|
+        @sub.setpos(i, 0)
+        @sub.addstr(line.ljust(@sub_width, " ")[0, @sub_width])
+      end
+
+      (visible.length...@sub_height).each do |i|
+        @sub.setpos(i, 0)
+        @sub.addstr(" " * @sub_width)
+      end
+
+      @sub.refresh
+    end
+
+    def destroy
+      @sub&.close
+      @frame&.close
+    rescue StandardError
+      # ignore
+    end
+  end
+end

data/lib/changelogger/repo_info.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Changelogger
+  # +Changelogger::RepoInfo+ holds metadata about the current repository.
+  #
+  # @!attribute [rw] name
+  #   @return [String] repo name (directory name)
+  # @!attribute [rw] path
+  #   @return [String] absolute repo root path
+  # @!attribute [rw] branch
+  #   @return [String] HEAD branch or "(detached)"
+  # @!attribute [rw] head_short
+  #   @return [String] abbreviated HEAD sha
+  # @!attribute [rw] remote
+  #   @return [String] remote.origin.url (may be empty)
+  # @!attribute [rw] remote_slug
+  #   @return [String, nil] "owner/repo" for GitHub remotes, otherwise nil
+  # @!attribute [rw] dirty
+  #   @return [Boolean] true if there are uncommitted changes
+  RepoInfo = Struct.new(:name, :path, :branch, :head_short, :remote, :remote_slug, :dirty, keyword_init: true)
+
+  # +Changelogger::Repo+ reads basic repository info for display.
+  class Repo
+    class << self
+      # +Changelogger::Repo.info+                      -> Changelogger::RepoInfo
+      #
+      # Reads repo root, branch, HEAD short sha, origin url, and dirty flag.
+      # @return [RepoInfo]
+      def info
+        path = cmd("git rev-parse --show-toplevel").strip
+        name = path.empty? ? File.basename(Dir.pwd) : File.basename(path)
+        branch = cmd("git rev-parse --abbrev-ref HEAD").strip
+        branch = "(detached)" if branch.empty? || branch == "HEAD"
+        head_short = cmd("git rev-parse --short HEAD").strip
+        remote = cmd("git config --get remote.origin.url").strip
+        dirty = !cmd("git status --porcelain").strip.empty?
+
+        RepoInfo.new(
+          name: name,
+          path: path.empty? ? Dir.pwd : path,
+          branch: branch,
+          head_short: head_short,
+          remote: remote,
+          remote_slug: to_slug(remote),
+          dirty: dirty
+        )
+      end
+
+      private
+
+      # +Changelogger::Repo.cmd+                        -> String
+      # @private
+      # Runs a shell command and returns its stdout (or empty string on error).
+      # @param [String] s shell command
+      # @return [String]
+      def cmd(s)
+        `#{s} 2>/dev/null`
+      rescue StandardError
+        ""
+      end
+
+      # +Changelogger::Repo.to_slug+                    -> String, nil
+      # @private
+      # Extracts owner/repo from GitHub remotes or returns nil for others.
+      # @param [String] url git remote URL
+      # @return [String, nil]
+      def to_slug(url)
+        return nil if url.to_s.empty?
+
+        if url =~ %r{\Agit@github\.com:([\w.-]+/[\w.-]+)(?:\.git)?\z}i
+          Regexp.last_match(1)
+        elsif url =~ %r{\Ahttps?://(?:www\.)?github\.com/([\w.-]+/[\w.-]+)(?:\.git)?\z}i
+          Regexp.last_match(1)
+        end
+      end
+    end
+  end
+end

data/lib/changelogger/tui.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "curses"
+require_relative "header"
+require_relative "branches_window"
+
+module Changelogger
+  # +Changelogger::TUI+ wraps curses lifecycle and runs the side-by-side UI.
+  class TUI
+    # +Changelogger::TUI.run+                         -> Array<String>, nil
+    #
+    # Starts curses, draws the header and graph/preview panes, and returns the
+    # selected anchor SHAs when the user presses Enter.
+    #
+    # @return [Array<String>, nil] array of SHAs (2+) or nil if cancelled (q/ESC)
+    def self.run
+      Curses.init_screen
+      Curses.cbreak
+      Curses.noecho
+      Curses.curs_set(0)
+      begin
+        begin
+          Curses.start_color
+          Curses.use_default_colors if Curses.respond_to?(:use_default_colors)
+        rescue StandardError
+        end
+        Changelogger::Header.new
+        win = Changelogger::BranchWindow.new
+        win.select_commits
+      ensure
+        begin
+          Curses.close_screen
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/changelogger/version.rb

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