Run any Skill in Manus with one click

commit-writer

Stars1

Forks0

UpdatedApril 3, 2026 at 04:20

Generates clear, consistent commit messages following Conventional Commits format with project-appropriate scopes and changelog-friendly structure. Covers commit types, scope selection, subject/body/footer rules, breaking changes, multi-package commits, and anti-pattern avoidance. Use when writing commits, reviewing staged changes, generating commit messages, or enforcing commit conventions. Triggers: commit, commit message, write commit, generate commit, staged changes, conventional commits, git commit, changelog.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

lushly-dev

lushly-dev/botcore

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Software DevelopersComputer and Mathematical Occupations·SOC 15-1252

SKILL.md

readonly

More from this repository

same repository

dependency-manager

lushly-dev/botcore

Guides dependency evaluation, selection, and lifecycle management for software projects. Covers package health assessment (OpenSSF Scorecard, maintenance signals, popularity metrics), vendoring vs forking decisions, major version upgrade strategies, automated update tooling (Dependabot, Renovate), supply chain security (SLSA, Sigstore, SBOM, provenance), monorepo dependency patterns, and agentic workflows for dependency operations. Use when evaluating new packages, adding dependencies, upgrading major versions, configuring automated updates, auditing dependency health, making vendor-or-fork decisions, or securing the software supply chain. Triggers: dependency, package, npm install, pip install, cargo add, upgrade, update, vendoring, fork, supply chain, SBOM, SLSA, Dependabot, Renovate, lockfile, vulnerability, dependency health, monorepo dependencies.

2026-06-281

dev-environment-learn

lushly-dev/botcore

Dev environment hygiene for agentic development. Prevents global package pollution, version drift, PATH entropy, and lockfile conflicts across Python, Node.js, and system tooling. Covers installation best practices, audit workflows, cleanup playbooks, and cross-platform patterns (Windows + macOS). Use when installing packages, configuring MCP servers, setting up toolchains, debugging import/resolution errors, or cleaning up polluted environments.

2026-06-281

botcore-architecture

lushly-dev/botcore

Botcore system architecture — component topology, data flow, security boundaries, and extension points. Covers core package structure, plugin registry flow, MCP server factory, agent orchestrator, memory subsystem, connector middleware stack, and cross-cutting concerns (audit, auth, config). Use when understanding how components connect, tracing request flow, planning new plugins or connectors, debugging integration issues, or reviewing architecture decisions. Triggers: architecture, component, data flow, request flow, middleware, plugin registry, MCP factory, orchestrator topology, connector stack, system diagram, how does botcore work.

2026-04-031

botcore-principles

lushly-dev/botcore

Core design principles and architectural tenets for the botcore ecosystem. Covers the foundational decisions that shape all implementation: CommandResult contract, opt-in composability, connector boundaries, meta-tool token efficiency, scoped memory, constrained agency, and plugin protocol. Use when making implementation decisions, reviewing designs for consistency, evaluating trade-offs, or onboarding to the project philosophy. Triggers: principles, design philosophy, why, trade-off, decision, architecture decision, CommandResult, connector boundary, composability, constrained agency.

2026-04-031

skill-manager

lushly-dev/botcore

Create, maintain, and validate agent skills following the Agent Skills open standard (agentskills.io). Covers SKILL.md format, frontmatter fields (open standard + Claude Code extensions), progressive disclosure, hooks, resource scripts, naming conventions, routing tables, and automated quality checks. Use when creating new skills, auditing existing skills, fixing lint errors, adding hooks to skills, or writing resource scripts for deterministic offloading. Triggers: create skill, new skill, skill lint, audit skills, SKILL.md, hooks, resource scripts, progressive disclosure, Agent Skills, open standard, skill architecture, deterministic offloading.

2026-04-031

accessibility-learn

lushly-dev/botcore

Provides comprehensive accessibility review, guidance, and implementation patterns for WCAG 2.1+ AA compliance. Covers keyboard navigation, ARIA roles and states, screen reader support, assistive technology analysis, compliance frameworks (Section 508, ADA, EN 301 549, EAA, ACA, CVAA), UX component patterns, and accessible content authoring. Use when building interactive components, auditing UI for accessibility, implementing focus management, reviewing designs or specs against WCAG, mapping issues to compliance frameworks, or creating accessibility checklists. Triggers: accessibility, a11y, WCAG, ARIA, keyboard navigation, screen reader, assistive technology, focus management, inclusive design, compliance, Section 508, ADA.

2026-04-031

name	commit-writer
source	botcore
description	Generates clear, consistent commit messages following Conventional Commits format with project-appropriate scopes and changelog-friendly structure. Covers commit types, scope selection, subject/body/footer rules, breaking changes, multi-package commits, and anti-pattern avoidance. Use when writing commits, reviewing staged changes, generating commit messages, or enforcing commit conventions. Triggers: commit, commit message, write commit, generate commit, staged changes, conventional commits, git commit, changelog.
version	1.0.0
triggers	["commit","commit message","write commit","generate commit","staged changes","conventional commits","git commit","changelog"]
portable	true

Writing Commits

Generate consistent, changelog-friendly commit messages following Conventional Commits format with project-appropriate scopes.

Capabilities

Commit Message Generation -- Analyze staged changes and produce well-structured Conventional Commits messages
Type Classification -- Identify the correct commit type (feat, fix, refactor, docs, etc.) from the nature of the change
Scope Selection -- Determine the appropriate scope from the project's package or module structure
Breaking Change Handling -- Format breaking changes with proper markers, migration notes, and footer conventions
Anti-Pattern Detection -- Identify and correct vague, overly long, mixed-concern, or improperly formatted commit messages
Changelog Alignment -- Ensure messages are structured for automated changelog generation

Core Principles

1. Conventional Commits Format

Every commit message follows this structure:

<type>(<scope>): <subject>

<body>

<footer>

type -- Required. Classifies the nature of the change.
scope -- Optional but recommended. Identifies the affected package, module, or area.
subject -- Required. Brief imperative description.
body -- Optional. Explains what and why.
footer -- Optional. Breaking changes, issue references, co-authors.

2. Commit Types

Type	Purpose	Example
`feat`	New feature or capability	`feat(auth): add OAuth2 token refresh`
`fix`	Bug fix	`fix(api): resolve timeout on large payloads`
`docs`	Documentation only	`docs: update API reference for v2 endpoints`
`style`	Formatting, no logic change	`style: fix linter warnings`
`refactor`	Code restructuring, no behavior change	`refactor(db): extract query builder`
`test`	Adding or updating tests	`test(auth): add token expiry edge cases`
`chore`	Maintenance, tooling	`chore: update dependencies`
`perf`	Performance improvement	`perf(cache): reduce lookup time with bloom filter`
`build`	Build system or external deps	`build: update tsconfig for ESM`
`ci`	CI/CD pipeline changes	`ci: add integration test workflow`

3. Subject Line Rules

Max 50 characters -- Keep it concise
Present tense -- "add" not "added"
Imperative mood -- "fix bug" not "fixes bug"
No trailing period
Lowercase start -- Begin with a lowercase letter

4. Body Rules

Wrap at 72 characters
Explain what and why, not how
Separate from subject with a blank line
Use bullet points for multiple changes

5. Footer Rules

Breaking changes -- Start with BREAKING CHANGE: on its own line
Issue references -- Closes #123 or Fixes #456
Co-authors -- Co-authored-by: Name <email>

6. Scope Selection

Scopes should reflect the project structure. Determine scopes by examining:

Monorepo packages -- Use package names (e.g., core, server, cli)
Application layers -- Use layer names (e.g., api, db, ui)
Feature areas -- Use domain names (e.g., auth, billing, search)
Multi-scope changes -- Comma-separate scopes (e.g., core,server)
Cross-cutting changes -- Omit scope when the change is truly global

Workflow

Generating a Commit Message

Analyze staged changes -- Run git diff --staged to understand what changed
Identify the type -- Classify as feat, fix, refactor, docs, etc.
Determine the scope -- Which package or module is affected
Write the subject -- Concise imperative description under 50 chars
Add body if needed -- For non-trivial changes, explain the reasoning
Add footer if needed -- Issue refs, breaking changes, co-authors

Breaking Change Format

Use the ! marker in the type/scope AND a BREAKING CHANGE: footer:

feat(api)!: rename UserResponse to UserResult

BREAKING CHANGE: All imports of UserResponse must be updated
to UserResult. The structure remains the same.

Migration:
- import { UserResponse } -> import { UserResult }
- UserResponse<T> -> UserResult<T>

Quick Reference: Good vs Bad

Avoid

# Too vague
fix: bug fix

# Wrong tense
feat(cli): added new command

# Too long subject
feat(server): implement comprehensive middleware system with logging, timing, rate limiting, and authentication support

# Missing scope when package is clear
feat: add batch execution

# Mixed concerns (should be two commits)
feat(server): add middleware and fix timeout bug

Prefer

# Specific
fix(client): prevent duplicate connections on reconnect

# Present tense, imperative
feat(cli): add format flag for output

# Concise subject with body for details
feat(server): add middleware system

Includes:
- Logging middleware with configurable levels
- Timing middleware for performance tracking
- Rate limiting with sliding window

# Clear scope
feat(server): add batch execution support

# Atomic -- one concern per commit
feat(server): add middleware pipeline
fix(server): handle timeout in long-running commands

Checklist

Type accurately reflects the nature of the change
Scope matches the affected package or module
Subject is under 50 characters
Subject uses imperative mood, present tense, lowercase, no period
Body (if present) explains what and why, wrapped at 72 characters
Breaking changes use both ! marker and BREAKING CHANGE: footer
Each commit addresses a single concern (no mixed feat + fix)
Issue references use proper format (Closes #N, Fixes #N)
Message is suitable for automated changelog generation

When to Escalate

Condition	Action
Change spans many packages with unrelated concerns	Split into multiple atomic commits
Unclear whether change is feat vs fix vs refactor	Review the diff -- if behavior changes for users it is feat or fix; if not, refactor
Breaking change with complex migration	Include detailed migration steps in the body and notify the team
Staged changes include unrelated modifications	Unstage unrelated files and commit separately
Commit would include secrets or credentials	Stop and remove sensitive content before committing