ai_git 0.2.0 → 1.0.1

data/lib/ai_git/commands/default.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+# lib/ai_git/commands/default.rb
+#
+# @purpose      Implement the default subcommand end to end: guard the staged
+#               diff, generate a commit message, confirm it, then commit and
+#               push.
+# @exports      AIGit::Commands::Default: .call, .run, .generate_commit_message,
+#               .normalize_message, .build_prompt.
+# @dependencies ai_git/options: parses the flags .call receives;
+#               ai_git/git: reads the staged tree, commits, and pushes;
+#               ai_git/secrets: screens the diff before it leaves the machine;
+#               ai_git/config: supplies the model name and base-URL checks;
+#               ai_git/ai_client: generates the message;
+#               ai_git/prompt: runs the interactive confirmation and editor;
+#               ai_git/ui: prints the header, the message, and the outcome.
+# @sideEffects  Reads the repository, commits, pushes to origin, makes network
+#               requests, spawns the editor, and writes to stdout and stderr;
+#               raises a string on any refusal.
+# @notes        Refuses to send the diff over plain http to a non-loopback host
+#               or to send likely secrets, unless --force is passed. The
+#               confirmation prompt is skipped unless both streams are a tty.
+
+require_relative "../ai_client"
+require_relative "../config"
+require_relative "../git"
+require_relative "../options"
+require_relative "../prompt"
+require_relative "../secrets"
+require_relative "../ui"
+
+module AIGit
+  module Commands
+    module Default
+      module_function
+
+      def generate_commit_message(diff, model_name, temperature: 0.3)
+        raise "No staged changes to generate commit message for" if diff.to_s.strip.empty?
+
+        message = AIClient.complete(
+          prompt: build_prompt(diff),
+          model_name: model_name,
+          temperature: temperature
+        )
+
+        message = normalize_message(message)
+        raise empty_response_error if message.empty?
+
+        message
+      end
+
+      def empty_response_error
+        "#{AIGit::Config.provider} returned an empty commit message. " \
+          "Check the model name and that the server is loaded (see `ai_git config`), then retry."
+      end
+
+      def normalize_message(message)
+        text = message.to_s.gsub(/\n{3,}/, "\n\n").strip
+        lines = text.lines.map(&:chomp)
+        return text if lines.length < 2
+
+        lines.insert(1, "") unless lines[1].empty?
+        lines.join("\n").gsub(/\n{3,}/, "\n\n").strip
+      end
+
+      def call(argv = [])
+        options = AIGit::Options.parse(argv)
+        return puts(AIGit::USAGE) if options.help?
+
+        staged = AIGit::Git.staged_files
+        raise "No staged files. Use `git add` first." if staged.strip.empty?
+
+        run(staged, options)
+      end
+
+      def run(staged, options)
+        diff = AIGit::Git.diff
+        branch = AIGit::Git.current_branch
+        model_name = AIGit::Config.model_name
+
+        check_base_url!(options)
+        check_secrets!(staged, diff, options)
+
+        print_header(AIGit::Config.provider, model_name, staged, branch)
+
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        message = resolve_message(diff, model_name, options)
+        return AIGit::UI.info("Aborted. Nothing committed.") if message.nil?
+
+        return dry_run_summary(branch, options) if options.dry_run?
+
+        commit_and_push(message, branch, options)
+        AIGit::UI.kv("Done in", format("%.1fs", Process.clock_gettime(Process::CLOCK_MONOTONIC) - started))
+      end
+
+      def resolve_message(diff, model_name, options)
+        loop do
+          AIGit::UI.info(AIGit::UI.bold("Generating commit message…"))
+          message = generate_commit_message(diff, model_name)
+          print_message(message)
+
+          return message unless confirm?(options)
+
+          case AIGit::Prompt.ask_action
+          when :accept then return message
+          when :edit then return edited_message(message)
+          when :abort then return nil
+          end
+        end
+      end
+
+      def confirm?(options)
+        !options.dry_run? && !options.assume_yes? && AIGit::Prompt.interactive?
+      end
+
+      def edited_message(message)
+        edited = normalize_message(AIGit::Prompt.edit(message))
+        raise "Aborted: the edited commit message is empty." if edited.empty?
+
+        print_message(edited)
+        edited
+      end
+
+      def commit_and_push(message, branch, options)
+        AIGit::Git.commit_with_message(message)
+        AIGit::UI.success("Committed.")
+
+        return AIGit::UI.info(AIGit::UI.dim("Skipped push (--no-push).")) unless options.push?
+
+        return AIGit::UI.warning("Detached HEAD: skipping push. Commit is local only.") if branch.nil?
+
+        AIGit::Git.push_current_branch
+        AIGit::UI.success("Pushed to origin/#{branch}.")
+      end
+
+      def dry_run_summary(branch, options)
+        outcome =
+          if !options.push?
+            "would commit only"
+          elsif branch.nil?
+            "would commit only (detached HEAD)"
+          else
+            "would commit and push to origin/#{branch}"
+          end
+
+        AIGit::UI.info(AIGit::UI.dim("Dry run: nothing changed, #{outcome}."))
+      end
+
+      def check_base_url!(options)
+        return if AIGit::Config.loopback_base_url?
+
+        host = AIGit::Config.base_uri.host
+
+        if AIGit::Config.insecure_remote_base_url? && !options.force?
+          raise "Refusing to send the staged diff unencrypted to #{host} over http. " \
+                "Use https, a loopback address, or pass --force."
+        end
+
+        AIGit::UI.warning("Warning: the full staged diff will be sent to #{AIGit::Config.base_url} (not this machine).")
+      end
+
+      def check_secrets!(staged, diff, options)
+        findings = AIGit::Secrets.scan(staged, diff)
+
+        findings[:warnings].each { |finding| AIGit::UI.warning("Warning: #{finding}.") }
+
+        blocking = findings[:blocking]
+        return if blocking.empty?
+
+        blocking.each { |finding| AIGit::UI.warning("Possible secret: #{finding}.") }
+        return if options.force?
+
+        raise "Refusing to send possible secrets to #{AIGit::Config.provider}. " \
+              "Unstage these files or pass --force."
+      end
+
+      def print_header(provider, model_name, staged, branch)
+        AIGit::UI.kv("AI Provider", provider)
+        AIGit::UI.kv("Model", model_name)
+        AIGit::UI.kv("Staged Files", staged.to_s.strip.gsub("\n", ", "))
+        AIGit::UI.kv("Branch", branch || "(detached HEAD)")
+        puts
+      end
+
+      def print_message(message)
+        puts
+        puts AIGit::UI.bold("Commit message:")
+        puts
+        puts message
+        puts
+      end
+
+      def build_prompt(diff)
+        standard_prompt(diff)
+      end
+
+      def standard_prompt(diff)
+        <<~PROMPT
+          You are an expert Git commit message writer. Output ONLY the commit message — no explanations, no markdown, no backticks, no preamble.
+
+          Here are the changes:
+          #{diff}
+
+          STRICT OUTPUT FORMAT (follow exactly):
+
+          <short imperative title, max 72 chars, summarizing the main change>
+
+          <blank line>
+
+          <body written as plain prose paragraphs, no headers, no bullet points, no tags.
+          Explain why the change is necessary and what problem it solves, how it addresses
+          the issue at a high level (do not recount line-by-line code changes, those are
+          visible in the diff), and any side effects or tradeoffs reviewers should know about.>
+
+          RULES:
+          - Title line: short, specific, imperative mood (e.g. "Add JWT login with refresh token support"). Avoid vague titles like "Update stuff" or "Fix bug".
+          - Body: plain prose only. No markdown headers, no bullet points, no bold/italics, no tags.
+          - Body: explain WHY the change is necessary and WHAT problem it solves, then HOW it addresses the issue at a high level. Do not describe the code line by line.
+          - Body: mention side effects or tradeoffs only if they exist and matter to a reviewer.
+          - No filler phrases ("this commit", "this PR", "as per discussion").
+          - No line should exceed 72 characters.
+
+          EXAMPLES OF GOOD OUTPUT:
+
+          Add JWT-based login with refresh token support
+
+          Users were being logged out on every page reload because sessions
+          were not persisted across requests. This made the app unusable for
+          any workflow longer than a single page view.
+
+          Introduces a login endpoint that issues short-lived access tokens
+          alongside long-lived refresh tokens, plus a refresh route that
+          rotates tokens on use. Refresh tokens are stored in encrypted
+          HTTP-only cookies so the client never handles them directly.
+
+          Adds a new middleware layer on private routes, so any route not
+          yet wired to it remains unauthenticated until migrated.
+
+          ---
+
+          Prevent nil crash when user preferences are missing
+
+          Reports were raising NoMethodError in production for accounts
+          created before the preferences feature shipped, since those
+          accounts have no preferences record at all.
+
+          Falls back to system defaults whenever a user's preferences are
+          absent, so report generation no longer assumes the record exists.
+
+          ---
+
+          Now generate the commit message:
+        PROMPT
+      end
+    end
+  end
+end

data/lib/ai_git/config.rb

@@ -1,44 +1,148 @@
 # frozen_string_literal: true
+# lib/ai_git/config.rb
+#
+# @purpose      Resolve the model provider settings from the defaults and the
+#               user's YAML config file, and judge whether the base URL is safe
+#               to send to.
+# @exports      AIGit::Config: PROVIDER, DEFAULT_MODEL, DEFAULT_BASE_URL,
+#               ENDPOINT, LOOPBACK_HOST, CONFIG_DIR_NAME, CONFIG_FILENAMES,
+#               SETTING_KEYS, TRUTHY_VALUES, .provider, .config_dir,
+#               .config_path, .settings, .reset!, .model_name, .base_url,
+#               .no_color?, .endpoint, .base_uri, .valid_uri?,
+#               .loopback_base_url?, .insecure_remote_base_url?.
+# @dependencies uri: parses and validates the configured base URL;
+#               yaml: parses ~/.ai_git/config.yml.
+# @sideEffects  Reads ~/.ai_git/config.yml on first use and memoizes it;
+#               raises a string on a malformed file, an unknown setting, or a
+#               malformed URL.
+# @notes        The file is read once per process, so .reset! exists to drop the
+#               memo. An unknown key raises rather than being ignored, so a
+#               typo never silently leaves the default in place. Only a loopback
+#               host keeps the diff on this machine, so every other host counts
+#               as remote for the plain-http refusal.
+
+require "uri"
+require "yaml"
 
 module AIGit
   module Config
-    PROVIDERS = {
-      "jan" => {
-        default_model: "Jan-v3.5-4B-Q4_K_XL",
-        base_url: "http://127.0.0.1:1337",
-        endpoint: "/v1/chat/completions",
-        request_format: :openai
-      },
-      "ollama" => {
-        default_model: "gemma4:e4b",
-        base_url: "http://localhost:11434",
-        endpoint: "/api/generate",
-        request_format: :ollama
-      }
-    }.freeze
+    PROVIDER = "llama_cpp"
+    DEFAULT_MODEL = "ggml-org/gemma-4-E4B-it-GGUF:Q8_0"
+    DEFAULT_BASE_URL = "http://127.0.0.1:8080"
+    ENDPOINT = "/v1/chat/completions"
+    LOOPBACK_HOST = /\A(localhost|127(\.\d{1,3}){3}|::1|0:0:0:0:0:0:0:1)\z/i.freeze
+    CONFIG_DIR_NAME = ".ai_git"
+    CONFIG_FILENAMES = %w[config.yml config.yaml].freeze
+    SETTING_KEYS = %w[model_name base_url no_color].freeze
+    TRUTHY_VALUES = [true, "true", "yes", "on", "1"].freeze
+
+    module_function
+
+    def provider
+      PROVIDER
+    end
+
+    def config_dir
+      File.join(Dir.home, CONFIG_DIR_NAME)
+    rescue ArgumentError
+      nil
+    end
+
+    def config_path
+      dir = config_dir
+      return nil if dir.nil?
+
+      CONFIG_FILENAMES.map { |name| File.join(dir, name) }.find { |path| File.file?(path) }
+    end
 
-    def self.provider
-      ENV["AI_GIT_AI_PROVIDER"] || "jan"
+    def settings
+      @settings ||= load_settings
     end
 
-    def self.model_name
-      ENV["AI_GIT_MODEL_NAME"] || PROVIDERS[provider][:default_model]
+    def reset!
+      @settings = nil
+    end
+
+    def load_settings
+      path = config_path
+      return {} if path.nil?
+
+      validate_settings(parse_file(path), path)
+    end
+
+    def parse_file(path)
+      YAML.safe_load_file(path) || {}
+    rescue Psych::SyntaxError => e
+      raise "Invalid YAML in #{path}: #{e.message}"
+    rescue SystemCallError => e
+      raise "Cannot read #{path}: #{e.message}"
+    end
+
+    def validate_settings(data, path)
+      raise "Invalid config in #{path}: expected a mapping of settings." unless data.is_a?(Hash)
+
+      data = data.transform_keys(&:to_s)
+      unknown = data.keys - SETTING_KEYS
+      return data if unknown.empty?
+
+      raise "Unknown setting#{'s' if unknown.length > 1} in #{path}: #{unknown.join(', ')}. " \
+            "Known settings: #{SETTING_KEYS.join(', ')}."
+    end
+
+    def string_setting(key, default)
+      value = settings[key]
+      return default if value.nil?
+
+      raise "Invalid #{key} in #{config_path}: expected a non-empty string." unless string_value?(value)
+
+      value.strip
+    end
+
+    def string_value?(value)
+      value.is_a?(String) && !value.strip.empty?
+    end
+
+    def model_name
+      string_setting("model_name", DEFAULT_MODEL)
+    end
+
+    def base_url
+      string_setting("base_url", DEFAULT_BASE_URL)
+    end
+
+    def no_color?
+      value = settings["no_color"]
+      value = value.downcase if value.is_a?(String)
+      TRUTHY_VALUES.include?(value)
+    end
+
+    def endpoint
+      ENDPOINT
+    end
+
+    def base_uri
+      uri = URI.parse(base_url)
+      raise invalid_base_url_error unless valid_uri?(uri)
+
+      uri
+    rescue URI::InvalidURIError
+      raise invalid_base_url_error
     end
 
-    def self.base_url
-      ENV["AI_GIT_BASE_URL"] || PROVIDERS[provider][:base_url]
+    def invalid_base_url_error
+      "Invalid base_url #{base_url.inspect}: expected an http(s) URL. See `ai_git config`."
     end
 
-    def self.endpoint
-      PROVIDERS[provider][:endpoint]
+    def valid_uri?(uri)
+      %w[http https].include?(uri.scheme) && !uri.host.to_s.empty?
     end
 
-    def self.request_format
-      PROVIDERS[provider][:request_format]
+    def loopback_base_url?
+      base_uri.host.to_s.delete("[]").match?(LOOPBACK_HOST)
     end
 
-    def self.config
-      PROVIDERS[provider]
+    def insecure_remote_base_url?
+      !loopback_base_url? && base_uri.scheme == "http"
     end
   end
 end

data/lib/ai_git/git.rb

@@ -1,26 +1,95 @@
 # frozen_string_literal: true
+# lib/ai_git/git.rb
+#
+# @purpose      Wrap the git porcelain this tool drives: inspect the staged
+#               tree, then commit and push on the user's behalf.
+# @exports      AIGit::Git: NOT_A_REPOSITORY, MAX_ERROR_DETAIL, .repository?,
+#               .ensure_repository!, .staged_files, .diff, .current_branch,
+#               .detached_head?, .commit_with_message, .push_current_branch.
+# @dependencies git: every operation shells out to the binary;
+#               open3: captures stdout, stderr, and exit status together;
+#               tempfile: holds the commit message passed to `git commit -F`.
+# @sideEffects  Spawns git subprocesses; writes a tempfile; mutates the
+#               repository and the remote on commit and push.
+# @notes        Raises a bare string message; bin/ai_git renders it and exits 1.
+
+require "open3"
+require "tempfile"
 
-require "English"
 module AIGit
   module Git
     module_function
 
+    NOT_A_REPOSITORY = "Not a git repository (or any of the parent directories)."
+    MAX_ERROR_DETAIL = 500
+
+    def repository?
+      _stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--git-dir")
+      status.success?
+    end
+
+    def ensure_repository!
+      raise NOT_A_REPOSITORY unless repository?
+    end
+
     def staged_files
-      `git diff --cached --name-only`
+      ensure_repository!
+      capture("git", "diff", "--cached", "--name-only")
     end
 
     def diff
-      `git diff --cached`
+      ensure_repository!
+      capture("git", "diff", "--cached")
     end
 
     def current_branch
-      result = `git rev-parse --abbrev-ref HEAD`
-      result.chomp
+      ensure_repository!
+      stdout, _stderr, status = Open3.capture3("git", "symbolic-ref", "--quiet", "--short", "HEAD")
+      return nil unless status.success?
+
+      branch = stdout.chomp
+      branch.empty? ? nil : branch
+    end
+
+    def detached_head?
+      current_branch.nil?
+    end
+
+    def capture(*argv)
+      stdout, stderr, status = Open3.capture3(*argv)
+      return stdout if status.success?
+
+      raise command_error(argv, stderr, status)
+    end
+
+    def run_command(cmd, *args)
+      argv = [cmd, *args.map(&:to_s)]
+      _stdout, stderr, status = Open3.capture3(*argv)
+
+      return if status.success?
+
+      raise command_error(argv, stderr, status)
+    end
+
+    def command_error(argv, stderr, status)
+      detail = stderr.to_s.strip
+      detail = "#{detail[0, MAX_ERROR_DETAIL]}…" if detail.length > MAX_ERROR_DETAIL
+      header = "Command failed: #{argv.join(' ')} (exit #{status.exitstatus})"
+
+      detail.empty? ? header : "#{header}\n#{detail}"
+    end
+
+    def commit_with_message(message)
+      Tempfile.create("ai_git_commit_msg") do |file|
+        file.write(message)
+        file.flush
+
+        run_command("git", "commit", "-F", file.path)
+      end
     end
 
-    def run_command(cmd, args)
-      system("#{cmd} #{args} > /dev/null 2>&1")
-      raise "Command failed: #{cmd} #{args}" if $CHILD_STATUS.exitstatus != 0
+    def push_current_branch
+      run_command("git", "push", "-u", "origin", "HEAD")
     end
   end
 end

data/lib/ai_git/options.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# lib/ai_git/options.rb
+#
+# @purpose      Parse the default command's flags into a value object that the
+#               command queries instead of re-reading the argument vector.
+# @exports      AIGit::Options: .parse, #dry_run?, #push?, #assume_yes?,
+#               #force?, #help?, and the matching accessors.
+# @sideEffects  None.
+# @notes        An unrecognized argument raises rather than being ignored, so a
+#               mistyped flag never silently commits and pushes.
+
+module AIGit
+  class Options
+    attr_accessor :dry_run, :push, :assume_yes, :force, :help
+
+    def initialize
+      @dry_run = false
+      @push = true
+      @assume_yes = false
+      @force = false
+      @help = false
+    end
+
+    def self.parse(argv)
+      argv.to_a.each_with_object(new) do |arg, options|
+        case arg
+        when "-n", "--dry-run" then options.dry_run = true
+        when "--no-push"       then options.push = false
+        when "-y", "--yes"     then options.assume_yes = true
+        when "-f", "--force"   then options.force = true
+        when "-h", "--help"    then options.help = true
+        else raise "Unknown option: #{arg}. Run `ai_git --help` for usage."
+        end
+      end
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    def push?
+      @push
+    end
+
+    def assume_yes?
+      @assume_yes
+    end
+
+    def force?
+      @force
+    end
+
+    def help?
+      @help
+    end
+  end
+end

data/lib/ai_git/prompt.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+# lib/ai_git/prompt.rb
+#
+# @purpose      Own the interactive confirmation step: ask what to do with the
+#               generated message, and open the user's editor on request.
+# @exports      AIGit::Prompt: ACTIONS, QUESTION, .interactive?, .ask_action,
+#               .edit.
+# @dependencies ai_git/ui: bolds the question before it is printed;
+#               shellwords: splits $VISUAL or $EDITOR into command and args;
+#               tempfile: holds the message the editor opens.
+# @sideEffects  Reads stdin and writes to stdout; spawns the editor process;
+#               writes a tempfile; reads $VISUAL and $EDITOR.
+# @notes        A closed stdin, where gets returns nil, is treated as an abort
+#               so a piped run never blocks waiting on an answer.
+
+require "shellwords"
+require "tempfile"
+
+require_relative "ui"
+
+module AIGit
+  module Prompt
+    module_function
+
+    ACTIONS = {
+      "" => :accept, "a" => :accept, "accept" => :accept, "y" => :accept, "yes" => :accept,
+      "e" => :edit, "edit" => :edit,
+      "r" => :regenerate, "regen" => :regenerate, "regenerate" => :regenerate,
+      "q" => :abort, "quit" => :abort, "n" => :abort, "no" => :abort, "abort" => :abort
+    }.freeze
+
+    QUESTION = "Commit this message? [A]ccept / [e]dit / [r]egenerate / [q]uit: "
+
+    def interactive?
+      $stdin.tty? && $stdout.tty?
+    end
+
+    def ask_action
+      loop do
+        $stdout.print AIGit::UI.bold(QUESTION)
+        $stdout.flush
+
+        answer = $stdin.gets
+        return :abort if answer.nil?
+
+        action = ACTIONS[answer.strip.downcase]
+        return action if action
+
+        AIGit::UI.info("Please answer a, e, r or q.")
+      end
+    end
+
+    def edit(message)
+      editor = ENV["VISUAL"] || ENV["EDITOR"]
+      raise "Cannot edit: set $EDITOR or $VISUAL first." if editor.to_s.strip.empty?
+
+      Tempfile.create(["ai_git_commit_msg", ".txt"]) do |file|
+        file.write(message)
+        file.flush
+
+        raise "Editor #{editor} exited with an error." unless system(*Shellwords.split(editor), file.path)
+
+        File.read(file.path)
+      end
+    end
+  end
+end