git-commit.sh

#!/bin/bash

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# set -x

# Debug mode flag
DEBUG=false
ECHO=false

# Debug function
debug_log() {
    if [ "$DEBUG" = true ]; then
        echo "DEBUG: $1"
        if [ ! -z "$2" ]; then
            echo "DEBUG: Content >>>"
            echo "$2"
            echo "DEBUG: <<<"
        fi
    fi
}

# Replace all linebreaks with proper JSON escaping
function replace_linebreaks() {
    local input="$1"
    printf '%s' "$input" | tr '\n' '\\n' | sed 's/\n$//'
}

while [[ $# -gt 0 ]]; do
    case $1 in
    --debug)
        DEBUG=true
        shift
        ;;
    --echo)
      ECHO=true
      shift
      ;;
    *)
        echo "Error: Unknown argument $1"
        exit 1
        ;;
    esac
done

# Get git changes and clean up any tabs
CHANGES=$(git diff --cached --name-status | tr '\t' ' ' | tr '\n' ' ' | sed 's/  */ /g')

# Get git diff for context
DIFF_CONTENT=$(git diff --cached --no-color)


if [ -z "$CHANGES" ]; then
    echo "No staged changes found. Please stage your changes using 'git add' first."
    exit 1
fi

debug_log "Git changes detected" "$CHANGES"

# Remove all linebreaks from CHANGES
CHANGES=$(replace_linebreaks "$CHANGES")

# Format changes into a single line and replace \M with newlines
FORMATTED_CHANGES=$(echo "$CHANGES" | sed 's/\\M/\n/g' | tr '\n' ' ' | sed 's/  */ /g')

# FORMATTED_DIFFS=$(escape_prompt "$DIFF_CONTENT")
FORMATTED_DIFF=$(echo "$DIFF_CONTENT" | tr '\n' '\\n' | sed 's/\\M/\\n/g' | sed 's/\\nM/\\n/g' | sed 's/"/\\"/g')

PROMPT=$(cat <<EOF
Generate a conventional commit message for these file changes:

$FORMATTED_CHANGES

and this git diff:

$DIFF_CONTENT

## Instructions:
- Start with a summary in imperitive mood.
- Explain the 'why' behind changes, when possible. Don\'t make anything up.
- Use bullet points for multiple changes, except for when the 'why' is attached to item
- Format should be:
<type>[optional scope wrapped in parens]: <description>

[optional body]

[optional footer(s)]

Rules:
The commit contains the following structural elements, to communicate intent to the consumers of your library:
1. fix: a commit of the type fix patches a bug in your codebase (this correlates with PATCH in Semantic Versioning).
2. feat: a commit of the type feat introduces a new feature to the codebase (this correlates with MINOR in Semantic Versioning).
3. BREAKING CHANGE: a commit that has a footer BREAKING CHANGE:, or appends a ! after the type/scope, introduces a breaking API change (correlating with MAJOR in Semantic Versioning). A BREAKING CHANGE can be part of commits of any type.
4. types other than fix: and feat: are allowed, for example @commitlint/config-conventional (based on the Angular convention) recommends build:, chore:, ci:, docs:, style:, refactor:, perf:, test:, and others.
5. footers other than BREAKING CHANGE: <description> may be provided and follow a convention similar to git trailer format.
6. Use 'fix' for minor changes
7. Do not wrap your response in triple backticks
8. Response should be the commit message only, no explanations as it will be passed directly to git.

Additional types are not mandated by the Conventional Commits specification, and have no implicit effect in Semantic Versioning (unless they include a BREAKING CHANGE). A scope may be provided to a commit’s type, to provide additional contextual information and is contained within parenthesis, e.g., feat(parser): add ability to parse arrays.
EOF
)

# Make the prompt safe for json
SAFE_PROMPT=$(jq -Rn --arg str "$PROMPT" '$str')
debug_log "Prompt" "$SAFE_PROMPT"

BASE_URL="https://api.githubcopilot.com/github/chat/threads"
HEADERS=( "Authorization: Bearer $(gh auth token)" )
CURL_HEADERS=()
for header in "${HEADERS[@]}"; do
    CURL_HEADERS+=(-H "$header")
done

# Create Thread
REQUEST_BODY="{}"
RESPONSE=$(curl -s -X POST "$BASE_URL" \
  "${CURL_HEADERS[@]}" \
  -d "$REQUEST_BODY" \
)

debug_log "Response" "$RESPONSE"

THREAD_ID=$(echo $RESPONSE | jq -r .thread_id)
if [ $? -ne 0 ]; then
  echo "Failed to fetch thread id"
  exit 1
fi
debug_log "Thread ID" "$THREAD_ID"

# Send prompt to gh
REQUEST_BODY=$(cat <<EOF
{
  "content": $SAFE_PROMPT,
  "intent": "cli-suggest",
  "references": [
    {
      "type": "cli-command",
      "program": "string"
    }
  ]
}
EOF
)
debug_log "Request Body" "$REQUEST_BODY"
RESPONSE=$(curl -s -X POST "$BASE_URL/$THREAD_ID/messages" \
  "${CURL_HEADERS[@]}" \
  -d "$REQUEST_BODY" \
)
debug_log "Response" "$( echo $RESPONSE | jq)"

CONTENT=$(echo "$RESPONSE" | jq -r .message.content)
if [ $? -ne 0 ]; then
  echo "Failed to fetch git message"
  exit 1
fi

# Clean the message:
# 1. Preserve the structure of the commit message
# 2. Clean up escape sequences
COMMIT_FULL=$(echo "$CONTENT" |
    sed 's/\\n/\n/g' |
    sed 's/\\r//g' |
    sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//' |
    sed 's/\\[[:alpha:]]//g')

debug_log "Extracted commit message" "$COMMIT_FULL"

if [ -z "$COMMIT_FULL" ]; then
    echo "Failed to generate commit message. API response:"
    exit 1
fi

# Execute git commit
if  [ "$ECHO" == true ]; then
  echo "$COMMIT_FULL"
  exit
fi

TMP_FILE="$(mktemp)"
echo "$COMMIT_FULL" > $TMP_FILE

debug_log "Executing git commit"
EDITOR_CMD="${GIT_EDITOR:-${EDITOR:-nvim}}"
GIT_EDITOR="$EDITOR_CMD" git commit --edit -F "$TMP_FILE"

if [ $? -ne 0 ]; then
    echo "Failed to commit changes"
    rm $TMP_FILE
    exit 1
fi

rm $TMP_FILE
echo "Successfully committed with message:"
echo "$COMMIT_FULL"
debug_log "Script completed successfully"