history-analysis

Analyze git history to learn project's commit style and conventions

8 stars

Best use case

history-analysis is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Analyze git history to learn project's commit style and conventions

Teams using history-analysis should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/history-analysis/SKILL.md --create-dirs "https://raw.githubusercontent.com/dhofheinz/open-plugins/main/plugins/git-commit-assistant/commands/history-analysis/skill.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/history-analysis/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How history-analysis Compares

Feature / Agenthistory-analysisStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Analyze git history to learn project's commit style and conventions

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# History Analysis Skill

**Purpose:** Analyze git commit history to learn project-specific commit patterns, conventions, scope usage, and message styles. Provides intelligent recommendations that match the team's existing practices.

## Router

Parse `$ARGUMENTS` to determine which history analysis operation to execute:

**Available Operations:**
- `analyze-style` - Learn commit style from recent history
- `detect-patterns` - Identify project-specific conventions
- `extract-scopes` - Discover commonly used scopes
- `suggest-conventions` - Recommend conventions based on history
- `learn-project` - Comprehensive project pattern learning
- `learn` - Alias for learn-project (full analysis)

**Base Directory:** `/home/danie/projects/plugins/architect/open-plugins/plugins/git-commit-assistant/commands/history-analysis`

## Routing Logic

```
Request: $ARGUMENTS
Parse: operation = first word, parameters = remainder

If operation is:
  - "analyze-style" → Read "./analyze-style.md" with parameters
  - "detect-patterns" → Read "./detect-patterns.md" with parameters
  - "extract-scopes" → Read "./extract-scopes.md" with parameters
  - "suggest-conventions" → Read "./suggest-conventions.md" with parameters
  - "learn-project" or "learn" → Read "./learn-project.md" with parameters
  - empty or unknown → Display usage information
```

## Usage Examples

```bash
# Analyze commit style from recent history
/history-analysis analyze-style

# Analyze with custom commit count
/history-analysis analyze-style count:100

# Detect project conventions
/history-analysis detect-patterns

# Extract common scopes
/history-analysis extract-scopes

# Get convention recommendations
/history-analysis suggest-conventions

# Full project learning (comprehensive analysis)
/history-analysis learn-project

# Short alias for full learning
/history-analysis learn
```

## Parameters

All operations support these optional parameters:
- `count:N` - Number of commits to analyze (default: 50)
- `branch:name` - Branch to analyze (default: current branch)
- `format:json|text` - Output format (default: text)

## Integration Points

This skill is designed to be invoked by:
- **commit-assistant agent** - Learn project conventions before generating messages
- **message-generation skill** - Validate messages against project style
- **User commands** - Understand project commit patterns

## Error Handling

If not in a git repository:
- Return error: "Not in a git repository. Please run this command from within a git project."

If no commit history exists:
- Return error: "No commit history found. This appears to be a new repository."

If git command fails:
- Return error with git error message and troubleshooting guidance

## Output Structure

All operations return structured data including:
- **Analysis results** - Patterns, frequencies, statistics
- **Recommendations** - Project-specific guidance
- **Examples** - Sample commits from project
- **Confidence score** - How reliable the analysis is

---

**Execution:**

1. Parse `$ARGUMENTS` to extract operation and parameters
2. Validate git repository exists
3. Read and execute the appropriate operation file
4. Return structured results

If operation is unrecognized, display:
```
Unknown operation: {operation}

Available operations:
  analyze-style       - Analyze commit message style
  detect-patterns     - Detect project conventions
  extract-scopes      - Extract common scopes
  suggest-conventions - Get convention recommendations
  learn-project       - Full project pattern learning

Usage: /history-analysis <operation> [parameters]
Example: /history-analysis analyze-style count:100
```

Related Skills

quality-analysis

8
from dhofheinz/open-plugins

Deep quality analysis with scoring, recommendations, and actionable reports

commit-analysis

8
from dhofheinz/open-plugins

Analyze git changes to understand nature, scope, and commit type for intelligent message generation

specification-writing

8
from dhofheinz/open-plugins

Core reference for EARS requirement patterns, Given/When/Then acceptance criteria, RFC 2119 language, requirement ID conventions, and specification quality checklists. Background knowledge for the spec-writer agent. Preloaded by spec-writer via the skills frontmatter field; not user-invocable.

refine

8
from dhofheinz/open-plugins

Unified specification refinement plugin. Single entry point for all spec operations: greenfield architecture pipelines (principles → design → stack → spec → plan), feature spec creation in existing systems, iterative convergence loops, quality reviews, drift detection, finalization, ticket decomposition, traceable updates, and lifecycle archival. Detects pipeline state from existing artifact frontmatter and routes intelligently. Use whenever you need to create, refine, validate, or evolve a technical specification.

validation-orchestrator

8
from dhofheinz/open-plugins

Intelligent validation orchestrator with auto-detection and progressive validation workflows

security-scan

8
from dhofheinz/open-plugins

Comprehensive security scanning for secrets, vulnerabilities, and unsafe practices

schema-validation

8
from dhofheinz/open-plugins

Validate JSON schemas, required fields, and format compliance for marketplaces and plugins

documentation-validation

8
from dhofheinz/open-plugins

Validate documentation completeness, format, and quality for plugins and marketplaces

best-practices

8
from dhofheinz/open-plugins

Enforce OpenPlugins and Claude Code best practices for naming, versioning, and standards compliance

message-generation

8
from dhofheinz/open-plugins

Generate conventional commit messages following best practices

commit-error-handling

8
from dhofheinz/open-plugins

Handle git errors and edge cases gracefully

commit-best-practices

8
from dhofheinz/open-plugins

Enforce git commit best practices and workflow guidance