commit-changes

Commit staged code changes in logical chunks using Conventional Commits.

130|21|Updated Jun 29, 2023
One-click install
npx skills add https://github.com/indexnetwork/index --skill commit-changes-indexnetwork
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: commit-changes
Source: https://github.com/indexnetwork/index/tree/main/.cursor/skills/commit-changes
Command: npx skills add https://github.com/indexnetwork/index --skill commit-changes-indexnetwork

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill streamlines the process of committing code changes by breaking them down into logical, modular units and adhering to the Conventional Commits specification for clear and consistent commit messages.

Core Features & Use Cases

  • Modular Committing: Analyzes git diff to identify logical changes and stages them in separate commits.
  • Conventional Commits: Enforces a standardized format for commit messages (<type>[optional scope]: <description>).
  • Use Case: When you've made several unrelated changes (e.g., a new feature, a bug fix, and documentation updates), this Skill helps you create separate, well-described commits for each, rather than one large, messy commit.

Quick Start

Use the commit-changes skill to stage and commit all modified files following conventional commit standards.

Frequently Asked Questions about commit-changes

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I split unrelated git changes into separate conventional commits?

To split unrelated git changes into separate conventional commits, the Skill analyzes git diff to identify logical changes, stages them in separate chunks, and applies the proper type, scope, and description for each commit.

What is the best way to write conventional commit messages for staged files?

Writing conventional commit messages for staged files involves enforcing a standardized format of type, optional scope, and description. The Skill automates this by planning logical staging and generating messages that adhere to the Conventional Commits specification.

How do I commit a new feature, bug fix, and docs update without creating one messy git commit?

To commit mixed updates without a messy git commit, the Skill breaks down multiple unrelated modifications into logical, modular units, creating separate, well-described commits for each change.

Can I stage and commit code in chunks based on the git diff automatically?

Yes, you can stage and commit code in chunks automatically. The Skill reviews the git diff to plan logical staging, then stages and commits the changes in modular chunks with appropriate conventional commit formatting.

When should I use modular commits instead of a single large commit?

You should use modular commits instead of a single large commit when you have made several unrelated changes, such as adding a feature, fixing a bug, and updating documentation, to maintain clear and consistent project history.

Does this conventional commits approach require any specific git workflow tools?

This conventional commits approach does not require specific git workflow tools. It operates directly on staged code changes using standard git diff analysis, requiring no additional dependencies to modularize and format commits.