gh-dhofheinz-open-plugins-plugins-git-commit-assistant/commands/commit-analysis/detect-type.md

description

description
Detect the appropriate conventional commit type based on git diff analysis

Operation: Detect Commit Type

Analyze git changes to determine the conventional commit type (feat, fix, docs, refactor, style, test, chore, perf, ci).

Parameters from $ARGUMENTS

No parameters required. Analyzes current git diff.

Workflow

Step 1: Verify Git Repository and Changes

git rev-parse --git-dir 2>/dev/null
git diff HEAD

If no repository or no changes, exit with appropriate message.

Step 2: Run Type Detection Algorithm

Execute the type detector script with git diff output:

git diff HEAD | .scripts/type-detector.py

The script implements the decision tree algorithm:

Detection Algorithm (Implemented in type-detector.py)

Priority Order (check in sequence):

1. Check for new files or new exports
   → IF new files OR new functions/classes/exports
   → RETURN "feat"

2. Check for bug fixes
   → IF error handling OR bug keywords (fix, resolve, correct)
   → RETURN "fix"

3. Check for docs-only changes
   → IF only .md files OR only comments changed
   → RETURN "docs"

4. Check for code restructuring
   → IF code moved/renamed but no behavior change
   → RETURN "refactor"

5. Check for style changes
   → IF only whitespace OR formatting changed
   → RETURN "style"

6. Check for test changes
   → IF only test files changed
   → RETURN "test"

7. Check for dependency changes
   → IF package.json OR build files changed
   → RETURN "build"

8. Check for CI changes
   → IF .github/workflows OR CI configs changed
   → RETURN "ci"

9. Check for performance improvements
   → IF optimization keywords OR caching added
   → RETURN "perf"

10. Default
    → RETURN "chore"

Step 3: Analyze Confidence Level

Determine confidence in the detected type:

High Confidence:

• Only one type detected
• Clear indicators present
• No ambiguity

Medium Confidence:

• Multiple possible types
• Mixed indicators
• Requires human judgment

Low Confidence:

• Unclear changes
• Multiple types with equal weight
• Recommend manual review

Step 4: Identify Alternative Types

If changes could fit multiple types, list alternatives:

Primary: feat (High confidence)
Alternatives:
  - test (if test files are significant)
  - docs (if documentation is substantial)

Step 5: Format Detection Result

Return structured type detection:

COMMIT TYPE DETECTION
═══════════════════════════════════════════════

DETECTED TYPE: <type>
CONFIDENCE: <High|Medium|Low>

REASONING:
───────────────────────────────────────────────
<detailed explanation of why this type was chosen>

Key Indicators:
- <indicator 1>
- <indicator 2>
- <indicator 3>

FILE ANALYSIS:
───────────────────────────────────────────────
New Files: X (suggests feat)
Bug Fixes: X (suggests fix)
Documentation: X (suggests docs)
Refactoring: X (suggests refactor)
Formatting: X (suggests style)
Tests: X (suggests test)
Dependencies: X (suggests build/chore)
CI/CD: X (suggests ci)

ALTERNATIVE TYPES:
───────────────────────────────────────────────
<if applicable>
- <type>: <reasoning>

RECOMMENDATION:
───────────────────────────────────────────────
<specific recommendation based on analysis>

═══════════════════════════════════════════════

Type Detection Rules

feat (Feature)

Indicators:

• New files created
• New functions/classes exported
• New functionality added
• New components/modules
• Keywords: "add", "implement", "introduce", "create"

Example Patterns:

+export function newFeature() {
+export class NewComponent {
+++ new-file.js

fix (Bug Fix)

Indicators:

• Error handling added
• Null/undefined checks
• Validation corrections
• Bug keywords in code
• Keywords: "fix", "resolve", "correct", "handle"

Example Patterns:

+if (!value) throw new Error
+try { ... } catch
-return null
+return value || default

docs (Documentation)

Indicators:

• Only .md files changed
• Only comments changed
• JSDoc additions
• README updates
• No code logic changes

Example Patterns:

+++ README.md
+// This function does...
+/** @param {string} name */

refactor (Code Restructuring)

Indicators:

• Code moved/reorganized
• Variables/functions renamed
• Logic extracted
• No behavior change
• Keywords: "extract", "rename", "simplify", "reorganize"

Example Patterns:

-function oldName() {
+function newName() {
-inline code block
+extractedFunction()

style (Formatting)

Indicators:

• Only whitespace changes
• Indentation fixes
• Semicolon additions/removals
• Code formatting
• No logic changes

Example Patterns:

-  const x = 1
+    const x = 1;
-function(a,b) {
+function(a, b) {

test (Tests)

Indicators:

• Only test files changed (.test.js, .spec.js, _test.py)
• Test additions/updates
• Mock/fixture changes
• Keywords: "describe", "it", "test", "expect"

Example Patterns:

+++ tests/feature.test.js
+describe('Feature', () => {
+it('should work', () => {

build (Build System)

Indicators:

• package.json changes
• Dependency updates
• Build configuration
• Build scripts

Example Patterns:

+++ package.json
+"dependencies": {
+  "new-lib": "^1.0.0"

ci (CI/CD)

Indicators:

• .github/workflows changes
• .gitlab-ci.yml changes
• CI configuration
• Deployment scripts

Example Patterns:

+++ .github/workflows/test.yml
+++ .gitlab-ci.yml

perf (Performance)

Indicators:

• Optimization changes
• Caching implementation
• Algorithm improvements
• Keywords: "optimize", "cache", "performance", "faster"

Example Patterns:

+const cache = new Map()
+if (cache.has(key)) return cache.get(key)
-O(n²) algorithm
+O(n log n) algorithm

chore (Other)

Indicators:

• Maintenance tasks
• Tooling configuration
• Repository housekeeping
• Doesn't fit other types

Output Format

Return:

• Detected type
• Confidence level
• Detailed reasoning
• Key indicators found
• Alternative types (if any)
• Specific recommendation

Error Handling

No changes:

NO CHANGES TO ANALYZE
Working tree is clean.

Ambiguous changes:

AMBIGUOUS TYPE DETECTION
Multiple types detected with equal weight.
Manual review recommended.

Detected types:
- feat (40%)
- refactor (35%)
- test (25%)

Integration with Agent

The commit-assistant agent uses this operation to:

1. Automatically determine commit type
2. Validate user-provided types
3. Suggest alternative types if ambiguous
4. Guide users in type selection

Usage Example

# Agent detects type before generating message
# User: "commit these changes"
# Agent: Invokes detect-type
# Operation: Returns "feat" with high confidence
# Agent: Generates message with "feat" type