403 lines
10 KiB
Markdown
403 lines
10 KiB
Markdown
---
|
||
description: Smart git commit with Linear integration and conventional commits
|
||
allowed-tools: [Bash, LinearMCP]
|
||
argument-hint: "[issue-id] [message]"
|
||
---
|
||
|
||
# Smart Commit Command
|
||
|
||
You are executing the **smart git commit command** that integrates with Linear and follows conventional commits format.
|
||
|
||
## 🚨 CRITICAL: Safety Rules
|
||
|
||
**READ FIRST**: ``$CCPM_COMMANDS_DIR/SAFETY_RULES.md``
|
||
|
||
This command performs **git operations** which are local and safe. No external PM system writes.
|
||
|
||
## Conventional Commits Format
|
||
|
||
This command follows the [Conventional Commits](https://www.conventionalcommits.org/) specification:
|
||
|
||
```
|
||
<type>(<scope>): <description>
|
||
|
||
[optional body]
|
||
|
||
[optional footer(s)]
|
||
```
|
||
|
||
**Types**:
|
||
- `feat`: New feature
|
||
- `fix`: Bug fix
|
||
- `docs`: Documentation changes
|
||
- `style`: Code style changes (formatting, etc.)
|
||
- `refactor`: Code refactoring
|
||
- `test`: Adding or updating tests
|
||
- `chore`: Maintenance tasks
|
||
|
||
## Implementation
|
||
|
||
### Step 1: Determine Issue ID
|
||
|
||
```javascript
|
||
const args = process.argv.slice(2)
|
||
let issueId = args[0]
|
||
let userMessage = args[1]
|
||
|
||
const ISSUE_ID_PATTERN = /^[A-Z]+-\d+$/
|
||
|
||
// If first arg doesn't look like issue ID, it might be the message
|
||
if (args[0] && !ISSUE_ID_PATTERN.test(args[0])) {
|
||
userMessage = args[0]
|
||
issueId = null
|
||
}
|
||
|
||
// Try to detect issue ID from git branch
|
||
if (!issueId) {
|
||
try {
|
||
const branch = execSync('git rev-parse --abbrev-ref HEAD', {
|
||
encoding: 'utf-8'
|
||
}).trim()
|
||
|
||
const branchMatch = branch.match(/([A-Z]+-\d+)/)
|
||
if (branchMatch) {
|
||
issueId = branchMatch[1]
|
||
console.log(`🔍 Detected issue from branch: ${issueId}`)
|
||
}
|
||
} catch (error) {
|
||
// Not in a git repo or branch detection failed
|
||
console.log("ℹ️ Could not detect issue from branch")
|
||
}
|
||
}
|
||
```
|
||
|
||
### Step 2: Check for Uncommitted Changes
|
||
|
||
```bash
|
||
# Get status
|
||
git status --porcelain
|
||
|
||
# Check if there are changes to commit
|
||
if [ -z "$(git status --porcelain)" ]; then
|
||
echo "✅ No changes to commit (working tree clean)"
|
||
exit 0
|
||
fi
|
||
```
|
||
|
||
### Step 3: Show Changes Summary
|
||
|
||
```markdown
|
||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
📝 Smart Commit Command
|
||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
|
||
${issueId ? `📋 Issue: ${issueId}` : ''}
|
||
|
||
📊 Changes to commit:
|
||
────────────────────
|
||
|
||
${changedFiles.map((file, i) => ` ${i+1}. ${file.status} ${file.path}`).join('\n')}
|
||
|
||
📈 Total: ${changedFiles.length} file(s) changed
|
||
|
||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
```
|
||
|
||
### Step 4: Fetch Issue Context (if Issue ID available)
|
||
|
||
If issue ID is available, get context from Linear:
|
||
|
||
```javascript
|
||
let issueTitle = null
|
||
let issueType = null
|
||
|
||
if (issueId) {
|
||
try {
|
||
const issue = await linear_get_issue(issueId)
|
||
issueTitle = issue.title
|
||
issueType = detectIssueType(issue)
|
||
|
||
console.log(`📋 Issue: ${issueId} - ${issueTitle}`)
|
||
console.log("")
|
||
} catch (error) {
|
||
console.log(`⚠️ Could not fetch issue ${issueId} from Linear`)
|
||
console.log(" Proceeding without issue context")
|
||
}
|
||
}
|
||
```
|
||
|
||
### Step 5: Analyze Changes and Determine Commit Type
|
||
|
||
```javascript
|
||
function analyzeChanges(changedFiles) {
|
||
const analysis = {
|
||
hasTests: false,
|
||
hasSource: false,
|
||
hasDocs: false,
|
||
hasConfig: false,
|
||
newFiles: 0,
|
||
modifiedFiles: 0
|
||
}
|
||
|
||
changedFiles.forEach(file => {
|
||
if (file.status === 'A' || file.status === '??') {
|
||
analysis.newFiles++
|
||
} else if (file.status === 'M') {
|
||
analysis.modifiedFiles++
|
||
}
|
||
|
||
if (file.path.includes('test') || file.path.includes('spec')) {
|
||
analysis.hasTests = true
|
||
} else if (file.path.includes('src/') || file.path.includes('lib/')) {
|
||
analysis.hasSource = true
|
||
} else if (file.path.match(/\.(md|txt)$/)) {
|
||
analysis.hasDocs = true
|
||
} else if (file.path.match(/\.(config|json|yaml|yml)$/)) {
|
||
analysis.hasConfig = true
|
||
}
|
||
})
|
||
|
||
return analysis
|
||
}
|
||
|
||
function suggestCommitType(analysis, issueType) {
|
||
// Priority order for determining type
|
||
if (issueType === 'bug') return 'fix'
|
||
if (issueType === 'feature') return 'feat'
|
||
|
||
// Infer from changes
|
||
if (analysis.hasSource && analysis.newFiles > 0) return 'feat'
|
||
if (analysis.hasSource && analysis.modifiedFiles > 0) {
|
||
// Could be feat, fix, or refactor - let user choose
|
||
return 'feat' // default to feat
|
||
}
|
||
if (analysis.hasTests && !analysis.hasSource) return 'test'
|
||
if (analysis.hasDocs && !analysis.hasSource) return 'docs'
|
||
if (analysis.hasConfig) return 'chore'
|
||
|
||
return 'feat' // default
|
||
}
|
||
```
|
||
|
||
### Step 6: Generate or Collect Commit Message
|
||
|
||
```javascript
|
||
let commitType, commitScope, commitDescription
|
||
|
||
if (userMessage) {
|
||
// User provided message, parse or use as-is
|
||
const conventionalMatch = userMessage.match(/^(\w+)(\([\w-]+\))?: (.+)$/)
|
||
|
||
if (conventionalMatch) {
|
||
// Already in conventional format
|
||
commitType = conventionalMatch[1]
|
||
commitScope = conventionalMatch[2]?.slice(1, -1) // Remove parens
|
||
commitDescription = conventionalMatch[3]
|
||
} else {
|
||
// Plain message, add conventional format
|
||
commitType = suggestCommitType(analysis, issueType)
|
||
commitScope = issueId ? issueId : null
|
||
commitDescription = userMessage
|
||
}
|
||
} else {
|
||
// Auto-generate from context
|
||
commitType = suggestCommitType(analysis, issueType)
|
||
commitScope = issueId ? issueId : null
|
||
|
||
// Generate description
|
||
if (issueTitle) {
|
||
commitDescription = issueTitle
|
||
} else {
|
||
// Generate from file changes
|
||
commitDescription = generateDescriptionFromChanges(analysis, changedFiles)
|
||
}
|
||
}
|
||
```
|
||
|
||
### Step 7: Display Proposed Commit Message
|
||
|
||
```markdown
|
||
💬 Proposed Commit Message:
|
||
───────────────────────────
|
||
|
||
${commitType}${commitScope ? `(${commitScope})` : ''}: ${commitDescription}
|
||
|
||
${issueId ? `
|
||
Related to: ${issueId}
|
||
${issueTitle ? `Issue: ${issueTitle}` : ''}
|
||
` : ''}
|
||
|
||
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||
```
|
||
|
||
### Step 8: Confirm and Commit
|
||
|
||
Use **AskUserQuestion** to confirm:
|
||
|
||
```javascript
|
||
{
|
||
questions: [{
|
||
question: "Proceed with this commit?",
|
||
header: "Confirm",
|
||
multiSelect: false,
|
||
options: [
|
||
{
|
||
label: "Yes, commit",
|
||
description: "Create commit with this message"
|
||
},
|
||
{
|
||
label: "Edit message",
|
||
description: "Let me modify the commit message"
|
||
},
|
||
{
|
||
label: "Cancel",
|
||
description: "Don't commit, go back"
|
||
}
|
||
]
|
||
}]
|
||
}
|
||
```
|
||
|
||
**If "Yes, commit"**:
|
||
|
||
```bash
|
||
# Stage all changes
|
||
git add .
|
||
|
||
# Create commit with conventional format
|
||
git commit -m "${commitType}${commitScope ? `(${commitScope})` : ''}: ${commitDescription}" \
|
||
${issueId ? `-m "Related to: ${issueId}"` : ''} \
|
||
${issueTitle ? `-m "${issueTitle}"` : ''}
|
||
|
||
echo "✅ Commit created successfully!"
|
||
echo ""
|
||
echo "Commit: $(git log -1 --oneline)"
|
||
echo ""
|
||
echo "Next steps:"
|
||
echo " /ccpm:sync # Sync progress to Linear"
|
||
echo " /ccpm:work # Continue working"
|
||
echo " git push # Push to remote"
|
||
```
|
||
|
||
**If "Edit message"**:
|
||
|
||
```markdown
|
||
Please provide your commit message (conventional format preferred):
|
||
|
||
Format: <type>(<scope>): <description>
|
||
Examples:
|
||
- feat(auth): add JWT token validation
|
||
- fix(PSN-27): resolve login button click handler
|
||
- docs: update API documentation
|
||
|
||
Your message:
|
||
> [User input]
|
||
```
|
||
|
||
Then repeat confirmation.
|
||
|
||
## Helper Functions
|
||
|
||
### Detect Issue Type
|
||
|
||
```javascript
|
||
function detectIssueType(issue) {
|
||
const title = issue.title.toLowerCase()
|
||
const labels = issue.labels || []
|
||
|
||
// Check labels first
|
||
if (labels.includes('bug') || labels.includes('fix')) return 'bug'
|
||
if (labels.includes('feature') || labels.includes('enhancement')) return 'feature'
|
||
|
||
// Check title keywords
|
||
if (title.includes('fix') || title.includes('bug')) return 'bug'
|
||
if (title.includes('add') || title.includes('implement')) return 'feature'
|
||
|
||
return 'feature' // default
|
||
}
|
||
```
|
||
|
||
### Generate Description from Changes
|
||
|
||
```javascript
|
||
function generateDescriptionFromChanges(analysis, changedFiles) {
|
||
if (analysis.newFiles > 0 && analysis.hasSource) {
|
||
const mainFile = changedFiles.find(f => f.status === 'A' && f.path.includes('src/'))
|
||
if (mainFile) {
|
||
const fileName = mainFile.path.split('/').pop().replace(/\.(ts|js|tsx|jsx)$/, '')
|
||
return `add ${fileName} module`
|
||
}
|
||
return `add new feature components`
|
||
}
|
||
|
||
if (analysis.modifiedFiles > 0 && analysis.hasSource) {
|
||
return `update implementation`
|
||
}
|
||
|
||
if (analysis.hasTests) {
|
||
return `add tests`
|
||
}
|
||
|
||
if (analysis.hasDocs) {
|
||
return `update documentation`
|
||
}
|
||
|
||
return `update files`
|
||
}
|
||
```
|
||
|
||
## Examples
|
||
|
||
### Example 1: Commit with Auto-Detection
|
||
|
||
```bash
|
||
git checkout -b duongdev/PSN-27-add-auth
|
||
# ... make changes ...
|
||
/ccpm:commit
|
||
```
|
||
|
||
**Detection**: PSN-27 from branch, fetches issue title from Linear
|
||
**Generated**: `feat(PSN-27): Add user authentication`
|
||
**Result**: Conventional commit created with Linear link
|
||
|
||
### Example 2: Commit with Custom Message
|
||
|
||
```bash
|
||
/ccpm:commit PSN-27 "Completed JWT token validation"
|
||
```
|
||
|
||
**Result**: `feat(PSN-27): Completed JWT token validation`
|
||
|
||
### Example 3: Commit with Full Conventional Format
|
||
|
||
```bash
|
||
/ccpm:commit "fix(auth): resolve login button handler"
|
||
```
|
||
|
||
**Result**: Uses provided conventional format as-is
|
||
|
||
### Example 4: Commit Without Issue ID
|
||
|
||
```bash
|
||
/ccpm:commit "update documentation"
|
||
```
|
||
|
||
**Result**: `docs: update documentation`
|
||
|
||
## Benefits
|
||
|
||
✅ **Conventional Commits**: Automatic format following best practices
|
||
✅ **Linear Integration**: Links commits to issues automatically
|
||
✅ **Smart Detection**: Auto-detects commit type from changes
|
||
✅ **Auto-Generation**: Creates meaningful messages from context
|
||
✅ **Git Integration**: Built into workflow (no context switching)
|
||
✅ **Change Summary**: Shows what's being committed before confirming
|
||
|
||
## Migration Hint
|
||
|
||
This is a NEW command that integrates git commits into CCPM workflow:
|
||
- Replaces manual `git add . && git commit -m "message"`
|
||
- Automatically follows conventional commits format
|
||
- Links commits to Linear issues
|
||
- Part of natural workflow (plan → work → commit → sync → verify → done)
|