[Feature Request] Add custom rules

[gitatmax]

For example, "summarize changes into a sentence for release notes" (instead of including long lists).

If this is already possible somehow from Claude Code's side, please close this!

[sponte]

Second that - it would be great if it could read the instructions from a file so I can redirect it to e.g. .vscode/copilot/commit-message-instructions.md

[DawidGrzejek]

Claude Commit Extension - Custom Commit Rules Feature

Overview

Added support for custom commit message instructions, allowing users to customize how Claude generates commit messages either through inline settings or external files. This addresses Issue #2.

Features Implemented

1. Inline Custom Instructions

Users can provide custom rules directly in VS Code settings via claude-commit.customInstructions.

2. File-Based Instructions

Users can specify a file path via claude-commit.instructionsFilePath to load instructions from a file (e.g., .vscode/copilot/commit-message-instructions.md).

Changes Made

package.json (Lines 78-87)

Added two new configuration options:

"claude-commit.customInstructions": {
  "type": "string",
  "default": "",
  "description": "Custom instructions for commit message generation (e.g., 'Summarize changes into a sentence for release notes')"
},
"claude-commit.instructionsFilePath": {
  "type": "string",
  "default": "",
  "description": "Path to a file containing custom commit message instructions (e.g., '.vscode/copilot/commit-message-instructions.md')"
}

1. Added Required Imports (Lines 6-7)

import * as fs from 'fs';
import * as path from 'path';

2. Enhanced Constructor Debug Logging (Lines 566-567)

outputChannel.appendLine(`customInstructions: ${this.config.get<string>('customInstructions') || 'not set'}`);
outputChannel.appendLine(`instructionsFilePath: ${this.config.get<string>('instructionsFilePath') || 'not set'}`);

3. New private method that handles loading custom instructions with the following logic: Priority Order:

1. File-based instructions (if instructionsFilePath is set)
2. Inline instructions (if customInstructions is set)
3. Default rules (if neither is set)

Key Features:

• Supports both relative (from workspace root) and absolute file paths
• Graceful error handling with debug logging
• Reads file using UTF-8 encoding

private async loadCustomInstructions(workspacePath: string): Promise<string> {
    let customInstructions = '';
    
    // First, try to load from file
    const instructionsFilePath = this.config.get<string>('instructionsFilePath');
    if (instructionsFilePath && instructionsFilePath.trim() !== '') {
        try {
            const resolvedPath = path.isAbsolute(instructionsFilePath)
                ? instructionsFilePath
                : path.join(workspacePath, instructionsFilePath);
                
            if (fs.existsSync(resolvedPath)) {
                customInstructions = fs.readFileSync(resolvedPath, 'utf8').trim();
            }
        } catch (error: any) {
            // Error logged if debugMode enabled
        }
    }
    
    // If no file instructions, use inline custom instructions
    if (!customInstructions) {
        const inlineInstructions = this.config.get<string>('customInstructions');
        if (inlineInstructions && inlineInstructions.trim() !== '') {
            customInstructions = inlineInstructions.trim();
        }
    }
    
    return customInstructions;
}

4. Modified Prompt Generation (Lines 641-676)

Updated generateCommitMessage() to use custom instructions.

Before:

const prompt = `Generate a git commit message for the following changes. 
...
Rules:
- Use conventional commit format
- Keep under 72 characters for the first line
- Be specific and clear
- Common types: feat, fix, docs, style, refactor, test, chore
...`;

After:

// Load custom instructions
const customInstructions = await this.loadCustomInstructions(cwd || '');

// Build prompt with default rules
let rulesSection = `Rules:
- Use conventional commit format
- Keep under 72 characters for the first line
- Be specific and clear
- Common types: feat, fix, docs, style, refactor, test, chore`;

// If custom instructions exist, use them instead
if (customInstructions) {
    rulesSection = `Custom Instructions:
${customInstructions}`;
}

const prompt = `Generate a git commit message for the following changes.
...
${rulesSection}
...`;

README.md

1. Updated Extension Settings Section (Lines 47-54)

Added documentation for the two new settings:

• claude-commit.customInstructions
• claude-commit.instructionsFilePath

2. Added Configuration Examples (Lines 74-106)

Added two new example sections: Custom Instructions (Inline):

{
    "claude-commit.customInstructions": "Summarize changes into a single sentence suitable for release notes. Focus on user-facing impact rather than technical details."
}

Custom Instructions (From File):

{
    "claude-commit.instructionsFilePath": ".vscode/copilot/commit-message-instructions.md"
}

With example file content:

Commit Message Instructions

• Summarize changes into a sentence for release notes
• Focus on the "why" rather than the "what"
• Use imperative mood (e.g., "Add feature" not "Added feature")
• Maximum 50 characters for the subject line
• Include ticket number if applicable: [TICKET-123] Subject

Technical Details

Instruction Priority

1. File-based instructions (highest priority) - Loaded from instructionsFilePath
2. Inline instructions (medium priority) - Read from customInstructions setting
3. Default rules (fallback) - Built-in conventional commit format rules

Path Resolution

• Relative paths: Resolved from workspace root
• Absolute paths: Used as-is
• Non-existent files: Silently falls back to inline instructions or defaults

Error Handling

• File reading errors are caught and logged (in debug mode)
• Missing files gracefully fall back to inline instructions
• Empty or whitespace-only content is treated as no instructions

Backward Compatibility

• Existing users without custom settings continue to use default rules
• No breaking changes to existing functionality
• All custom instruction settings are optional

Use Cases

• Individual Developers
• Use inline instructions for personal commit message preferences:

{
    "claude-commit.customInstructions": "Use emoji prefixes: ✨ for features, 🐛 for fixes"
}

Teams

Share commit conventions via version-controlled file:

{
    "claude-commit.instructionsFilePath": ".vscode/commit-rules.md"
}

[DawidGrzejek]

For example, "summarize changes into a sentence for release notes" (instead of including long lists).

If this is already possible somehow from Claude Code's side, please close this!

Second that - it would be great if it could read the instructions from a file so I can redirect it to e.g. .vscode/copilot/commit-message-instructions.md

Quick Fix for Immediate Use

If you want to use this feature right now without waiting for the official release, you can manually edit the compiled JavaScript file.

⚠️ Warning

This is a temporary workaround. Your changes will be overwritten when the extension updates. Use at your own risk.

Step-by-Step Instructions

1. Locate the Extension File

Windows:
%USERPROFILE%.vscode\extensions\juanlb.claude-commit-*\out\extension.js

macOS/Linux:
~/.vscode/extensions/juanlb.claude-commit-*/out/extension.js

2. Find the Prompt Generation Section

Open extension.js and search for this code (around line 635-660):

const fileType = isStaged ? 'staged files' : 'changed files';
if (this.debugMode) {
    outputChannel.appendLine(`\n[PROMPT] Creating prompt for ${fileType}...`);
}
// Build prompt with hardcoded conventional format
const prompt = `Generate a git commit message for the following changes.

3. Replace with Custom Instructions Code

Replace the prompt generation section with this:

const fileType = isStaged ? 'staged files' : 'changed files';
if (this.debugMode) {
    outputChannel.appendLine(`\n[PROMPT] Creating prompt for ${fileType}...`);
}

// Load custom instructions
const fs = require('fs');
const path = require('path');
let customInstructions = '';

// Try to load from file first
const instructionsFilePath = this.config.get('instructionsFilePath');
if (instructionsFilePath && instructionsFilePath.trim() !== '') {
    try {
        const resolvedPath = path.isAbsolute(instructionsFilePath)
            ? instructionsFilePath
            : path.join(cwd, instructionsFilePath);
        
        if (fs.existsSync(resolvedPath)) {
            customInstructions = fs.readFileSync(resolvedPath, 'utf8').trim();
            if (this.debugMode) {
                outputChannel.appendLine(`[INSTRUCTIONS] Loaded ${customInstructions.length} chars from file`);
            }
        }
    } catch (error) {
        if (this.debugMode) {
            outputChannel.appendLine(`[INSTRUCTIONS] Error reading file: ${error.message}`);
        }
    }
}

// If no file instructions, use inline custom instructions
if (!customInstructions) {
    const inlineInstructions = this.config.get('customInstructions');
    if (inlineInstructions && inlineInstructions.trim() !== '') {
        customInstructions = inlineInstructions.trim();
    }
}

// Build prompt with default or custom rules
let rulesSection = `Rules:
- Use conventional commit format
- Keep under 72 characters for the first line
- Be specific and clear
- Common types: feat, fix, docs, style, refactor, test, chore`;

if (customInstructions) {
    rulesSection = `Custom Instructions:
${customInstructions}`;
    
    if (this.debugMode) {
        outputChannel.appendLine(`[PROMPT] Using custom instructions (${customInstructions.length} chars)`);
    }
}

const prompt = `Generate a git commit message for the following changes.

IMPORTANT: Return ONLY the commit message text itself. Do not include:
- Any explanatory text like "Based on...", "Here's...", or "Here is..."
- Code blocks or backticks
- Any markdown formatting
- Any commentary before or after the message

Just return the raw commit message text that will be used directly in git commit.

Git diff:
${diff}

${rulesSection}

Remember: Return ONLY the commit message text, nothing else.`;

4. Add Configuration Support

Find the configuration section near the top of the file (around line 560) where it says:

if (this.debugMode) {
    outputChannel.appendLine('\n=== CONFIGURATION ===');
    outputChannel.appendLine(`claudePath: ${this.config.get('claudePath') || 'not set'}`);
    outputChannel.appendLine(`debugMode: ${this.debugMode}`);
}

Add these two lines after debugMode:

outputChannel.appendLine(`customInstructions: ${this.config.get('customInstructions') || 'not set'}`);
outputChannel.appendLine(`instructionsFilePath: ${this.config.get('instructionsFilePath') || 'not set'}`);

5. Configure Your Settings

Add to your VS Code settings (.vscode/settings.json or User Settings):

Option A - Inline Instructions:

{
    "claude-commit.customInstructions": "Summarize changes into a single sentence suitable for release notes. Focus on user-facing impact rather than technical details."
}

Option B - File-Based Instructions:

{
    "claude-commit.instructionsFilePath": ".vscode/copilot/commit-message-instructions.md"
}

Then create the instructions file with your custom rules.