source ~/.bash_profile

MAX_DIFF_CHARS=300 # ~75 input tokens — halves prefill vs 600

TIMEOUT_SECONDS=120 # covers cold model.load_weights() (~90s) + inference

MAX_COMMIT_LENGTH=120 # Increased — fits two-clause summaries without truncation

SQUISH_MODEL="${SQUISH_MODEL:-1.5b}"

SQUISH_PORT="${SQUISH_PORT:-11435}"

RED='\033[0;31m'

GREEN='\033[0;32m'

YELLOW='\033[0;33m'

BLUE='\033[0;34m'

PURPLE='\033[0;35m'

CYAN='\033[0;36m'

WHITE='\033[1;37m'

GRAY='\033[0;90m'

BOLD='\033[1m'

DIM='\033[2m'

NC='\033[0m' # No Color

_json_str() {

}

snake_spinner() {

}

print_header() {

}

print_step() {

echo -e "${CYAN}▸${NC} $1"

}

print_success() {

echo -e "${GREEN}✓${NC} $1"

}

print_warning() {

echo -e "${YELLOW}⚠${NC} $1"

}

print_error() {

echo -e "${RED}✗${NC} $1"

}

print_info() {

echo -e "${GRAY} $1${NC}"

}

print_header

print_step "Staging changes..."

git add -A

print_success "Changes staged"

base_branch=$(git rev-parse --abbrev-ref HEAD)

print_info "Branch: ${CYAN}$base_branch${NC}"

default_branch=$(git rev-parse --abbrev-ref origin/HEAD | sed 's@^origin/@@')

print_info "Default: ${GRAY}$default_branch${NC}"

ticket=$(echo $base_branch | grep -o -E '([A-Za-z]+-[0-9]{3,}|[A-Za-z]+-[0-9]{3,})')

if [ -n "$ticket" ]; then

print_info "Ticket: ${YELLOW}$ticket${NC}"

echo ""

changed_files=$(git diff --cached --name-only | head -3)

first_file=$(echo "$changed_files" | head -1)

file_count=$(git diff --cached --name-only | wc -l | tr -d ' ')

print_step "Files changed: ${WHITE}$file_count${NC}"

echo "$changed_files" | while read file; do

if [ -n "$file" ]; then

print_info " ${BLUE}$file${NC}"

fi

if [ "$file_count" -gt 3 ]; then

print_info " ${GRAY}...and $((file_count - 3)) more${NC}"

echo ""

if [ "$file_count" -eq 1 ]; then

fallback_message="${first_file} updated"

elif [ "$file_count" -gt 1 ]; then

fallback_message="${first_file} and $((file_count - 1)) other file(s) updated"

fallback_message="Updated ${base_branch} branch"

diff=$(git diff --cached | head -c $MAX_DIFF_CHARS)

SQUISH_FLAGS=""

if [ -n "$SQUISH_MODEL" ]; then

SQUISH_FLAGS="--model $SQUISH_MODEL"

if [ -n "$SQUISH_PORT" ]; then

SQUISH_FLAGS="$SQUISH_FLAGS --port $SQUISH_PORT"

export SQUISH_MODELS_DIR="${SQUISH_MODELS_DIR:-$HOME/squish/models}"_SQUISH_CLI="/Users/wscholl/squish/squish/cli.py"

SQUISH_BIN=$(command -v squish 2>/dev/null)

if echo "$SQUISH_BIN" | grep -q '^alias '; then

SQUISH_BIN=""

if [ -z "$SQUISH_BIN" ] && [ -f "$_SQUISH_CLI" ]; then

SQUISH_BIN="python3 $_SQUISH_CLI"

print_info "squish binary: ${CYAN}$SQUISH_BIN${GRAY} (alias not in bash PATH, using direct path)${NC}"

elif [ -n "$SQUISH_BIN" ]; then

print_info "squish binary: ${CYAN}$SQUISH_BIN${NC}"

print_warning "squish not found in PATH — will use fallback message"

commit_message="$fallback_message"

if [ -n "$SQUISH_BIN" ]; then

# Show which model / port will be used

if [ -n "$SQUISH_MODEL" ]; then

print_info "squish model: ${CYAN}$SQUISH_MODEL${NC}"

else

print_info "squish model: ${GRAY}auto-detect${NC}"

fi

print_info "squish port: ${CYAN}${SQUISH_PORT:-8000}${NC}"

# Check if a server is already listening on the port

_port="${SQUISH_PORT:-8000}"

if nc -z 127.0.0.1 "$_port" 2>/dev/null; then

print_info "squish server: ${GREEN}already running on :$_port${NC}"

else

print_info "squish server: ${YELLOW}not running — starting it now…${NC}"

# Draft model for speculative decoding — 1.5B drafts tokens, 7B verifies in

# one forward pass. ~2-3x generation speedup; same output quality as 7B alone.

_draft_model="${SQUISH_MODELS_DIR}/Qwen2.5-1.5B-Instruct-bf16-int8-bak"

_draft_flag=""

[ -d "$_draft_model" ] && _draft_flag="--draft-model $_draft_model"

# Start the server in the background and wait for it

$SQUISH_BIN serve ${SQUISH_MODEL:+--model $SQUISH_MODEL} --port "$_port" \

--kv-cache-mode int8 \

$_draft_flag \

> /tmp/squish_serve.log 2>&1 &

_serve_pid=$!

# Run snake spinner in background while polling for server readiness

snake_spinner "Starting squish server" &

_snake_pid=$!

_waited=0

while [ $_waited -lt 90 ] && ! nc -z 127.0.0.1 "$_port" 2>/dev/null; do

sleep 1

_waited=$((_waited + 1))

done

kill "$_snake_pid" 2>/dev/null

wait "$_snake_pid" 2>/dev/null

printf "\r \r"

if ! nc -z 127.0.0.1 "$_port" 2>/dev/null; then

print_warning "Server failed to start. Using fallback message."

commit_message="$fallback_message"

else

print_success "Server ready (${_waited}s)"

fi

fi

echo ""

if [ -z "$commit_message" ]; then

# Build a focused prompt — stat summary + truncated diff

stat_summary=$(git diff --cached --stat | tail -1)

changed_names=$(git diff --cached --name-only | head -10 | tr '\n' ' ')

# Strip diff to +/- lines only (awk, no Python)

stripped_diff=$(git diff --cached | awk '

# Build JSON payload in pure bash — _json_str escapes all special chars

# /no_think disables Qwen3 chain-of-thought so the model replies directly.

_sys="Write a git commit message. Imperative mood, under 72 chars, no punctuation. Reply with ONLY the message."

_usr="/no_think Files: ${changed_names}\nStat: ${stat_summary}\nDiff:\n${stripped_diff}"

PAYLOAD='{"model":"squish","messages":[{"role":"system","content":"'"$(_json_str "$_sys")"'"},{"role":"user","content":"'"$(_json_str "$_usr")"'"}],"max_tokens":150,"temperature":0.2,"stream":false,"stop":["\n","\r"]}'

# Run squish — curl in background, spinner inline in foreground (no subprocess)

print_step "Asking AI for commit message (Squish local LLM)..."

_port="${SQUISH_PORT:-11435}"

curl -s --max-time $TIMEOUT_SECONDS \

-X POST "http://127.0.0.1:${_port}/v1/chat/completions" \

-H "Content-Type: application/json" \

-H "Authorization: Bearer ${SQUISH_API_KEY:-squish}" \

-d "$PAYLOAD" 2>/tmp/squish_stderr.txt \

> /tmp/squish_response.txt &

LLM_PID=$!

# Inline spinner — runs in the main shell, no subprocess, no background PID

_sp_frames=('⣾' '⣽' '⣻' '⢿' '⡿' '⣟' '⣯' '⣷')

_sp_cols=("$CYAN" "$BLUE" "$PURPLE" "$CYAN" "$BLUE" "$PURPLE" "$CYAN" "$BLUE")

_si=0; _step=0

while kill -0 "$LLM_PID" 2>/dev/null; do

_secs=$(( _step / 10 )); _tenths=$(( _step % 10 ))

printf "\r${_sp_cols[$_si]}${_sp_frames[$_si]}${NC} ${WHITE}Generating commit message${NC}${GRAY}...${NC} ${DIM}(${_secs}.${_tenths}s)${NC} "

sleep 0.1

_si=$(( (_si + 1) % 8 ))

_step=$(( _step + 1 ))

done

wait $LLM_PID # reap immediately — zombie cleared within one loop tick

exit_code=$?

printf "\r${GREEN}✓${NC} ${WHITE}Done!${NC} \n"

# step is already in tenths of a second — free decimal timing, no extra call

_llm_secs=$(( _step / 10 )); _llm_tenths=$(( _step % 10 ))

print_info "model response time: ${CYAN}${_llm_secs}.${_llm_tenths}s${NC}"

# ── Debug: result diagnostics ─────────────────────────────────────────

raw_response=$(cat /tmp/squish_response.txt 2>/dev/null)

squish_stderr=$(cat /tmp/squish_stderr.txt 2>/dev/null)

rm -f /tmp/squish_response.txt /tmp/squish_stderr.txt

# Extract content from JSON robustly, then strip any CoT tags.

# Prefer jq when available; keep a shell-only fallback.

if command -v jq >/dev/null 2>&1; then

commit_message=$(printf '%s' "$raw_response" | jq -r '.choices[0].message.content // .message.content // empty' 2>/dev/null)

else

commit_message=$(printf '%s' "$raw_response" | sed -n 's/.*"content":"\([^"]*\)".*/\1/p')

commit_message=${commit_message//\\n/$'\n'}

commit_message=${commit_message//\\r/$'\r'}

commit_message=${commit_message//\\t/$'\t'}

commit_message=${commit_message//\\\//\/}

commit_message=${commit_message//\\\"/\"}

commit_message=${commit_message//\\u003c/<}

commit_message=${commit_message//\\u003e/>}

fi

# Remove <think> tags/content even when partial or multiline.

commit_message=$(printf '%s' "$commit_message" | perl -0777 -pe 's#<think>.*?</think>\s*##gis; s#<think\b[^>]*>.*##gis; s#</think>##gis' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')

# If any think tag residue remains, force fallback by clearing it.

if printf '%s' "$commit_message" | grep -qi '</\?think\b'; then

commit_message=""

fi

print_info "squish exit code: ${CYAN}$exit_code${NC}"

if [ -n "$commit_message" ]; then

print_info "squish parsed message: ${GREEN}\"$commit_message\"${NC}"

else

print_info "squish parsed message: ${RED}<empty>${NC}"

if [ -n "$raw_response" ]; then

print_info "squish raw body: ${YELLOW}$(echo "$raw_response" | head -c 500)${NC}"

else

print_info "squish raw body: ${RED}<no response from server>${NC}"

fi

fi

if [ -n "$squish_stderr" ]; then

print_info "squish stderr: ${YELLOW}$(echo "$squish_stderr" | head -3)${NC}"

fi

echo ""

# Check if timeout occurred or empty response

if [ $exit_code -eq 28 ] || [ $exit_code -eq 124 ]; then

print_warning "squish timed out after ${TIMEOUT_SECONDS}s (exit $exit_code). Using fallback message."

commit_message="$fallback_message"

elif [ -z "$commit_message" ]; then

print_warning "squish returned empty response. Using fallback message."

commit_message="$fallback_message"

else

print_success "squish responded successfully"

fi

fi

commit_message=$(echo "$commit_message" | sed 's/#//g' | sed 's/```//g' | sed 's/Commit message://gi' | sed 's/\.//g' | sed 's/\"//g' | sed "s/'//g" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')

if [ ${#commit_message} -gt $MAX_COMMIT_LENGTH ]; then

commit_message=$(echo "$commit_message" | cut -c1-$MAX_COMMIT_LENGTH | sed 's/[[:space:]][^[:space:]]*$//')

if [ -z "$commit_message" ] || [ "$commit_message" == "null" ]; then

commit_message="$fallback_message"

echo ""

echo -e "${PURPLE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

echo -e "${BOLD}${WHITE} 📝 Commit Message${NC}"

echo -e "${PURPLE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

if [ -n "$ticket" ]; then

echo -e " ${YELLOW}$ticket${NC} ${WHITE}$commit_message${NC}"

echo -e " ${WHITE}$commit_message${NC}"

echo -e "${PURPLE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

echo ""

export COMMIT_MESSAGE="$commit_message"

export TICKET="$ticket"

print_step "Committing changes..."

if [ -z "$ticket" ]; then

expect <<'EOF' > /dev/null 2>&1

expect <<'EOF' > /dev/null 2>&1

print_success "Committed successfully"

remote_branch=$(git ls-remote --heads origin $base_branch)

pull_push_after_failed_push() {

}

if [ -z "$remote_branch" ]; then

# If the branch does not exist on the remote, create it

print_step "Creating remote branch..."

set -e

git push --set-upstream origin $base_branch > /dev/null 2>&1

# Check if the push was successful

if [ $? -ne 0 ]; then

pull_push_after_failed_push

fi

print_success "Branch created and pushed"

# Branch exists on the remote, push changes

print_step "Pushing to remote..."

git fetch origin $base_branch > /dev/null 2>&1

git pull > /dev/null 2>&1

git push > /dev/null 2>&1

# Check if the push wasn't successful

if [ $? -ne 0 ]; then

pull_push_after_failed_push

fi

print_success "Pushed successfully"

show_pushed_banner() {

}

show_pushed_banner