commit

Git Commit

Create atomic commits by staging the right files, analyzing the staged diff, composing a conventional commit message, and optionally pushing.

Workflow

1) Pre-flight + context (single call)

Run all checks and context collection in one bash call:

git rev-parse --is-inside-work-tree \
  && ! test -d "$(git rev-parse --git-dir)/rebase-merge" \
  && ! test -f "$(git rev-parse --git-dir)/MERGE_HEAD" \
  && ! test -f "$(git rev-parse --git-dir)/CHERRY_PICK_HEAD" \
  && git symbolic-ref HEAD \
  && git status --short --branch

If any check fails, stop with a clear error and suggested fix.

Arguments: $ARGUMENTS

2) Parse arguments

• Flags:
  • --all commit all changes
  • --deep deep analysis, breaking changes, concise body
  • --push push after commit
  • --close <issue_numbers> append Closes #N trailers for listed issues (comma/space-separated)
• Value arguments:
  • Type keyword (any conventional type) overrides inferred type
  • Quoted text overrides inferred description

3) Stage + read diff

• If --all:
  • If no changes at all: error "No changes to commit"
  • If unstaged changes exist: git add -A
  • If already staged: proceed
• Otherwise (atomic commits):
  • Session-modified files = files edited in this session
  • Currently staged files: git diff --cached --name-only
  • For staged files NOT in session-modified set: git restore --staged <file>
  • For session-modified files with changes: git add <file>
  • If none: error "No files modified in this session"
• Unrelated changes: session-modified files may contain pre-existing uncommitted changes (hunks not from this session). Include the entire file—partial staging is impractical. Never revert, discard, or git checkout unrelated changes.
• Read the staged diff once: git diff --cached
• Log staged files with status (A/M/D)

4) Analyze + compose message

Read the staged diff and produce the commit message in a single pass.

Type inference — determine from behavior:

Behavior	Type
New functionality	feat
Bug fix / error handling	fix
Code reorganization, no behavior change	refactor
Documentation	docs
Tests	test
Build system (webpack, vite, esbuild)	build
CI/CD pipelines	ci
Dependencies	chore(deps)
Formatting / whitespace only	style
Performance	perf
Reverting previous commit	revert
AI config (CLAUDE.md, .claude/, .gemini/, .codex/)	ai
Other maintenance	chore

Explicit type keyword in arguments takes precedence over inference.

Scope — infer only when path makes it obvious (lowercase).

Unrelated hunks — ignore pre-existing changes when determining type/scope/description. If unrelated changes are in the same file as session changes, they are included in the commit scope but should not influence the message.

Message format:

• Subject line (<= 50 chars): type(scope): description or type: description
• Imperative mood ("add" not "added"), lowercase, no period
• Describe what the change does, not which files changed
• Body: hyphenated lines for distinct changes; skip for trivial changes

Issue linking — scan the chat transcript for GitHub issue references (e.g. #123, owner/repo#123, issue URLs) that the current changes resolve. For each match, append a Closes #N trailer. Skip issues merely mentioned in passing; include only ones the commit actually closes.

If --deep:

• Deep semantic analysis; detect breaking changes
• Infer scope from code structure even when path isn't clear
• Body: 2-3 hyphenated lines max, focus on WHY
• Breaking change: BREAKING CHANGE: + one-line migration note

If --close:

• Append a Closes #N line for each issue number provided
• Multiple issues: one Closes #N per line in the body/trailer
• Merge with transcript-scanned issues; de-duplicate

5) Commit

• Use git commit -m "subject" (add -m "body" only if body is non-empty)
• Output: commit hash + subject + file count summary
• If failed: show error + suggest fix

6) Push (if --push)

• If upstream exists: git push
• If no upstream: git push -u origin HEAD
• If failed: show error + suggest fix (pull/rebase first, set upstream, check auth)