feat(git): update --include-logs to optionally pack git commit history with graphs, metadata, and diffs/patches #968

ahundt · 2025-11-25T04:39:49Z

Choose which to pack: commit graphs, metadata, and diffs to analyze changes

Enhances --include-logs to include structured git commit data with optional diff/patch content, using orthogonal flags that mirror git log's own options.

Why

To evaluate repository history for cleanup, review, or AI analysis, info is needed beyond commit messages:

Diffs — diff content shows exactly what lines were added/removed
Commit Dependencies — parent hashes reveal commit relationships
How work was integrated — branch/merge topology shows integration points
Where releases are — tag mappings identify version boundaries

This adds these capabilities through flags that match git log's parameter structure.

Features

Graph Visualization (`--graph`) — NEW

ASCII graph: same format as git log --graph --oneline --all
Mermaid diagram: renders in GitHub, GitLab, documentation sites
Shows branch connections within the specified commit range

Commit Metadata

With --include-logs (existing): date, message, files

Add any output verbosity/graph option (--graph/--stat/--patch/--summary/etc.) for NEW fields:

Hashes: full SHA and abbreviated for referencing
Parents: merge commits show 2+ parents
Author: name, email, timestamp — who wrote the code
Committer: name, email, timestamp — may differ in cherry-picks, rebases
Body: full commit message body

Patch/Diff Content (`--patch`, `--stat`, etc.) — NEW

Include actual code changes — see exactly what lines were added, removed, or modified per commit. Choose detail level with diff format options.

Tag Mapping (`--graph`) — NEW

Maps git tags to commit hashes for identifying release boundaries. Included with graph visualization.

CLI Options

repomix --include-logs [--commit-range <range>] [--stat|--patch|...] [--graph] [path/to/repo]

Diff Format Options (mutually exclusive, mirrors git log):

Option	Git Equivalent	What it does	Why you'd use it
`--name-only`	`--name-only`	Filenames only	Default — see what files changed
`--stat`	`--stat`	Per-file change counts	See scope without full diffs
`--patch`	`--patch`	Line-by-line diffs	Evaluate actual code changes
`--numstat`	`--numstat`	Machine-readable +/-	Programmatic analysis
`--shortstat`	`--shortstat`	One-line summary	Quick overview
`--dirstat`	`--dirstat`	Directory percentages	See which areas changed most
`--name-status`	`--name-status`	Filenames with A/M/D/R	Track adds, mods, deletes, renames
`--raw`	`--raw`	Low-level with blob SHAs	Detailed analysis

Output Verbosity & Graph Options (combinable with diff format):

Option	Git Equivalent	What it does	Default
`--graph`	`--graph --all`	ASCII + Mermaid graphs	off
`--summary`	`--summary`	File operations (create/delete/rename)	off
`--commit-range <range>`	`<range>`	Specify commit range	`HEAD~50..HEAD`
`--include-logs-count <n>`	`-n`	Limit commits	50

Usage Examples

# Full diffs for code review
repomix --include-logs --patch

# Analyze release range with graph
repomix --include-logs --commit-range v1.0..v2.0 --stat --graph

# Review feature branch
repomix --include-logs --commit-range main..feature --stat --graph

# Quick scope overview
repomix --include-logs --shortstat

Performance

Measured over 10 runs each on repomix repo (median with min-max range, lower duration is better):

Test Suite Comparison:

Metric	Main (`a63546b`)	This PR (`586d3ae`)	Change	Notes
Total Duration	3.58s (3.57-3.73s)	3.62s (3.57-3.71s)	✅ +1.1%	Within variance
Test Files	96	97	✅ +1	New gitHistory.test.ts
Test Count	852	884	✅ +32	+3.8% coverage

gitLogHandle.test.ts (10 runs each, tests the changed code, lower duration is better):

Metric	Main (`a63546b`)	This PR (`586d3ae`)	Change
Median	344ms	255ms	🚀 -26%
Min	278ms	249ms	🚀 -10%
Max	896ms	296ms	🚀 -67%
Range	618ms	47ms	🚀 -92%

Repomix Execution (repomix --include-logs on repomix repo, 10 runs each, lower duration is better):

Metric	Main (`a63546b`)	This PR (`586d3ae`)	Change	Notes
Execution time	10.83s (10.69-10.99s)	10.39s (10.00-10.75s)	🚀 -4%	Faster with more features

Backwards Compatibility

Preserved:

All existing CLI arguments (--include-logs, --include-logs-count, --include-diffs) remain unchanged;
Core XML structure: <git_logs>, <git_log_commit>, <date>, <message>, <files>
Default behavior with --include-logs alone produces equivalent output
New fields are optional and only appear when new flags are used

Changed (Minor):

Date format: 2025-11-20 23:12:33 +0900 → 2025-11-26T04:30:33-05:00 (strict ISO 8601)
- More parseable format using git's %aI instead of %ad with --date=iso
- Both are ISO 8601 variants; the new format includes T separator and colon in timezone
- This is a minor format change that improves parseability for automated tools
All new new flags (--stat, --patch, --graph, --summary, --commit-range, etc.) are purely additive.

New optional sections (only when using enhancement flags):

<hash>, <author>, <committer>, <parents>, <body>, <patch> per commit
<summary> section with commit counts and range info
<commit_graph> section with ASCII and Mermaid visualizations

Output Structure

GitLogCommit with progressive fields:

interface GitLogCommit {
  date: string;
  message: string;
  files: string[];
  // Extended (with --graph, --stat, --patch, --summary, etc.):
  hash?: string;
  abbreviatedHash?: string;
  author?: { name: string; email: string; date: string };
  committer?: { name: string; email: string; date: string };
  parents?: string[];
  body?: string;
  patch?: string;
}

Checklist

npm run test — 884 tests pass
npm run lint — 0 errors, 0 warnings
Documentation updated
Backward compatible (--include-logs behavior preserved)

coderabbitai · 2025-11-25T04:40:00Z

Important

Review skipped

Auto incremental reviews are disabled on this repository.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Note

Other AI code review bot(s) detected

CodeRabbit has detected other AI code review bot(s) in this pull request and will avoid duplicating their findings in the review comments. This may lead to a less comprehensive review.

Walkthrough

This PR adds comprehensive Git commit history analysis capabilities to Repomix, introducing CLI flags (--patch, --stat, --graph, --summary, --commit-range) and configuration options to retrieve, parse, and render structured commit metadata, patches, ASCII/Mermaid graphs, and tags. The implementation spans CLI parsing, config schema, core git parsing utilities, output generation, and documentation.

Changes

Cohort / File(s)	Summary
CLI Options & Configuration `src/cli/types.ts`, `src/cli/cliRun.ts`, `src/cli/actions/defaultAction.ts`	Adds new CliOptions fields (commitRange, stat, patch, numstat, shortstat, dirstat, nameOnly, nameStatus, raw, graph, summary); registers CLI flags with grouping (Git Log Diff Format Options, Git Log Output Verbosity & Graph Options); wires flags into cliConfig with mutual-exclusion validation and commitPatchDetail derivation.
Config Schema `src/config/configSchema.ts`	Extends git output config with commitRange (default 'HEAD~50..HEAD'), commitPatchDetail (default 'name-only'), includeCommitGraph, includeSummary, includeGitTags, includeCommitPatches fields in both base and default schemas.
Git History Core `src/core/git/gitCommand.ts`, `src/core/git/gitHistory.ts`, `src/core/git/gitLogHandle.ts`	Introduces structured git output parsing layer with NUL delimiters; adds CommitMetadata, CommitGraph, ParsedCommitRange interfaces; implements parseCommitRange, getCommitMetadata, getCommitGraph, getTags, getCommitPatch, generateMermaidGraph functions; refactors git log handling to two-pass structured parsing with optional patches and graph.
Output Generation `src/core/output/outputGeneratorTypes.ts`, `src/core/output/outputGenerate.ts`, `src/core/output/outputStyles/markdownStyle.ts`, `src/core/output/outputStyles/xmlStyle.ts`	Extends RenderContext with gitCommitHistorySummary and gitCommitGraph; updates markdown/XML output templates to render commit history sections (graph, summary, commits with metadata, patches, tags).
Integration `src/core/packager.ts`, `src/core/metrics/calculateGitLogMetrics.ts`, `src/core/security/securityCheck.ts`	Updates GitLogCommit shape to include optional hash, abbreviatedHash, author, committer, parents, body, patch fields; adjusts metrics calculation and security checks to consume new logCommits structure instead of logContent.
Tests — Config & Metrics `tests/config/configSchema.test.ts`, `tests/core/metrics/calculateGitDiffMetrics.test.ts`, `tests/core/metrics/calculateGitLogMetrics.test.ts`	Extends mock RepomixConfig with new git fields; updates GitLogResult shape expectations to use logCommits array instead of logContent/commits.
Tests — Git & Output `tests/core/git/gitHistory.test.ts`, `tests/core/git/gitLogHandle.test.ts`, `tests/core/output/outputGenerate.test.ts`, `tests/core/output/outputGenerateDiffs.test.ts`, `tests/core/output/outputGenerateMarkdownStyle.test.ts`, `tests/core/output/outputGenerateXmlStyle.test.ts`	Adds comprehensive test suite for gitHistory functions (parseCommitRange, getCommitMetadata, getTags, getCommitPatch, getCommitGraph); refactors gitLogHandle tests to mock structured output and NUL-separated parsing; extends output tests to verify new git history rendering across markdown/XML/JSON.
Tests — Utilities `tests/cli/actions/workers/defaultActionWorker.test.ts`, `tests/core/output/flagFullDirectoryStructure.test.ts`, `tests/core/output/outputStyles/jsonStyle.test.ts`	Updates mock RepomixConfigMerged.git with new fields (commitRange, commitPatchDetail, includeCommitGraph, includeSummary, includeGitTags, includeCommitPatches).
Documentation — English `README.md`, `llms-install.md`, `website/client/src/en/guide/command-line-options.md`, `website/client/src/en/guide/configuration.md`, `website/client/src/en/guide/output.md`, `website/client/src/en/guide/usage.md`, `website/client/src/en/guide/tips/git-commit-history.md`	Adds sections documenting Git Commit History Analysis feature: CLI options (diff format flags, output detail/graph options, commit-range syntax), configuration defaults, output components (metadata, ASCII/Mermaid graphs, tags, patches), and usage examples/workflows.
Documentation — Translations `website/client/src/*/guide/command-line-options.md` (de, es, fr, hi, id, ja, ko, pt-br, vi, zh-cn, zh-tw)	Adds translated Git Commit History Options sections describing orthogonal diff flags and output options; consistent content across languages with some duplication within files.
Documentation — Navigation & Other `website/client/.vitepress/config/configEnUs.ts`, `.gitignore`	Adds sidebar navigation entry for Git Commit History Analysis guide; adds `.claude` to gitignore.

Sequence Diagram(s)

sequenceDiagram
    participant CLI as CLI<br/>(cliRun.ts)
    participant Action as Action<br/>(defaultAction.ts)
    participant GitCmd as Git Commands<br/>(gitCommand.ts)
    participant GitHist as Git History<br/>(gitHistory.ts)
    participant GitLog as Git Log Handle<br/>(gitLogHandle.ts)
    participant Output as Output Generate<br/>(outputGenerate.ts)
    participant Render as Render Styles<br/>(markdown/xml/json)

    CLI->>Action: Parse flags (--patch, --graph, --summary, --commit-range)
    Action->>Action: Validate mutual exclusion, derive commitPatchDetail
    Action->>Action: Augment cliConfig with git options
    
    Action->>GitLog: getGitLogs(config, deps)
    
    GitLog->>GitCmd: execGitLogStructured(range, maxCommits)
    GitCmd-->>GitLog: NUL-delimited structured metadata
    
    GitLog->>GitHist: parseCommitRange(range)
    GitHist-->>GitLog: { from, to, raw }
    
    alt includeCommitPatches
        GitLog->>GitCmd: execGitLogTextBlob(range, patchDetail)
        GitCmd-->>GitLog: patch/stat/diff text blobs
    end
    
    alt includeCommitGraph
        GitLog->>GitCmd: execGitGraph(range)
        GitCmd-->>GitLog: git log --graph output
        GitLog->>GitHist: generateMermaidGraph(commits, tags)
        GitHist-->>GitLog: Mermaid diagram string
    end
    
    GitLog->>GitHist: getTags(directory)
    GitHist-->>GitLog: tag→hash map
    
    GitLog-->>Action: GitLogResult { logCommits[], graph?, summary? }
    
    Action->>Output: generateOutput(context, gitLogResult)
    Output->>Output: Build RenderContext with gitCommitHistorySummary, gitCommitGraph
    Output->>Render: Render git history section
    Render->>Render: Format commits, patches, graph, tags per style
    Render-->>Output: Rendered markdown/XML/JSON
    Output-->>Action: Final output string

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~60 minutes

gitCommand.ts & gitHistory.ts (~25 min): Multi-pass git command architecture with structured NUL-delimited parsing requires careful review of delimiter handling, regex patterns, and error paths. Note: gitCommand.ts contains apparent duplicate declarations of NUL, METADATA_FORMAT, GitLogStructuredOptions, GitLogTextBlobOptions, execGitLogStructured, execGitLogTextBlob, execGitGraph—confirm if intentional or merge artifact.
gitLogHandle.ts refactor (~20 min): Significant restructuring from simple text parsing to two-pass structured approach; parseStructuredOutput helper regex patterns and Mermaid graph generation logic need verification for correctness and edge cases.
CLI integration & config wiring (~10 min): Multiple touch points (cliRun.ts, defaultAction.ts, configSchema.ts) require tracing flag→config→output flow to ensure mutual-exclusion validation and commitPatchDetail derivation work correctly.
Output generation complexity (~10 min): RenderContext changes, optional field rendering across markdown/XML/JSON styles, and new data shape (logCommits vs. logContent) must be validated for consistency.
Test coverage (~5 min): Extensive test additions are largely straightforward mock-based tests, though gitLogHandle.test.ts refactor adds structured parsing expectations that should be spot-checked.

Areas requiring extra attention:

Duplicate code block in src/core/git/gitCommand.ts (lines near end of file repeating NUL constant, METADATA_FORMAT, and all three exec* functions)
NUL delimiter parsing robustness for edge cases (empty output, incomplete records, special characters in commit messages)
Mermaid graph generation for complex merge scenarios and tag escaping
Integration with existing packager/metrics/security flows to ensure logCommits structure properly replaces logContent
Semantic consistency between CliOptions (snake_case: nameOnly, nameStatus) and command-line flags (kebab-case: --name-only, --name-status)

Possibly related issues

Add --include-logs option to include git log --name-status output #540: Main implementation of Git commit history analysis feature with CLI flags, config schema, and git log collection—this PR appears to be a complete realization of that feature proposal.

Possibly related PRs

Improve CLI help text clarity and accuracy #831: Modifies CLI option definitions and help text in src/cli/cliRun.ts; directly overlaps with new git-log-related flag additions in this PR.
Add comprehensive JSON output format support #837: Updates output generation (src/core/output/outputGenerate.ts) to add enriched git-log data to render context and JSON parsable output; directly conflicts with RenderContext changes here.
feat(cli): Add --include-logs option for git commit history #793: Implements Git commit-history features (CLI, config, git handling, output templates); substantial overlap in modified modules (src/core/git/, src/cli/, src/core/output/*).

Suggested labels

enhancement, git, feature

Suggested reviewers

yamadashy

Pre-merge checks and finishing touches

✅ Passed checks (3 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title clearly and specifically summarizes the main change: enhancing --include-logs to pack git commit history with graphs, metadata, and diffs/patches. It is concise, related to the primary objective, and conveys meaningful information.
Description check	✅ Passed	The pull request description is comprehensive and exceeds template requirements. It includes a detailed explanation of changes (Why, Features, CLI Options, Usage Examples, Performance), backwards compatibility assessment, output structure, and a complete checklist with verification that npm run test and npm run lint have been executed.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

gemini-code-assist · 2025-11-25T04:40:23Z

Summary of Changes

Hello @ahundt, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request significantly enhances the repomix tool by introducing a robust Git commit history analysis feature. This allows AI systems to gain a deeper understanding of code evolution, development patterns, and contextual information beyond just current file contents. By providing detailed commit metadata, visual graphs, and configurable patch levels, the tool now offers richer insights crucial for advanced AI-driven code analysis and understanding.

Highlights

Comprehensive Git Commit History Analysis: Introduced a new feature to analyze and include detailed Git commit history in the output, providing rich metadata, visual graphs (ASCII and Mermaid), and configurable patch details for AI systems.
New CLI Options and Configuration: Added six new CLI options (--include-commit-history, --commit-range, --commit-patch-detail, --no-commit-graph, --no-git-tags, --no-commit-patches) and corresponding configuration schema updates to give users fine-grained control over Git history extraction.
Enhanced Output Formats: Integrated the new Git commit history data into both Markdown and XML output styles, ensuring structured and comprehensive presentation for downstream AI analysis.
New Core Modules for Git Operations: Developed dedicated core modules (src/core/git/gitHistory.ts and src/core/git/gitHistoryHandle.ts) to manage Git command execution, parse commit data, and orchestrate the history collection process.
Extensive Documentation and Testing: Updated README.md, llms-install.md, and the project website with new guides and examples for the Git commit history feature, complemented by 871 new unit and integration tests to ensure reliability.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	`/gemini review`	Performs a code review for the current pull request in its current state.
Pull Request Summary	`/gemini summary`	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	`/gemini help`	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

coderabbitai

Actionable comments posted: 4

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/core/output/outputGenerate.ts (1)

66-119: Add missing git_commit_history section to XML output.

The generateParsableXmlOutput function is missing the git_commit_history section in the xmlDocument structure. The RenderContext provides gitCommitHistoryEnabled, gitCommitHistorySummary, gitCommitHistoryItems, and gitCommitGraph, and the XML template supports rendering this data (xmlStyle.ts line 83+), but the XML builder code does not include it. The JSON output correctly includes this section (lines 160-172). Add the conditional git_commit_history block to the xmlDocument object in generateParsableXmlOutput to match JSON output functionality.

🧹 Nitpick comments (3)

website/client/src/en/guide/tips/git-commit-history.md (2)

32-38: Clarify the relationship between --no-commit-patches and --commit-patch-detail metadata.

Both options appear to produce metadata-only output. The comment on line 37 says they're equivalent, but having two ways to achieve the same result could confuse users.

Consider clarifying:

When to use each option

Whether they're truly equivalent or have subtle differences

Whether one is preferred over the other

40-50: Consider adding privacy guidance for sensitive metadata.

Line 49 mentions that author/committer email addresses are included in the output. While this transparency is good, consider adding a note about:

Privacy implications when sharing output

How to filter or anonymize this data if needed

Whether the security check covers PII in git metadata
src/core/git/gitHistoryHandle.ts (1)
89-98: Consider parallel execution for better performance.

The sequential for...of loop processes commits one at a time. For larger commit ranges, parallel execution could improve performance.
-    const commits: HistoryCommitResult[] = [];
-    for (const metadata of graph.commits) {
-      // Get patch if requested
-      const patch = includePatches ? await deps.getCommitPatch(gitRoot, metadata.hash, detailLevel) : '';
-
-      commits.push({
-        metadata,
-        patch,
-      });
-    }
+    const commits: HistoryCommitResult[] = await Promise.all(
+      graph.commits.map(async (metadata) => ({
+        metadata,
+        patch: includePatches ? await deps.getCommitPatch(gitRoot, metadata.hash, detailLevel) : '',
+      })),
+    );

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 7c3af7a and fcd2874.

⛔ Files ignored due to path filters (1)

package-lock.json is excluded by !**/package-lock.json

📒 Files selected for processing (30)

README.md (2 hunks)
llms-install.md (2 hunks)
src/cli/actions/defaultAction.ts (1 hunks)
src/cli/cliRun.ts (2 hunks)
src/cli/types.ts (1 hunks)
src/config/configSchema.ts (2 hunks)
src/core/git/gitHistory.ts (1 hunks)
src/core/git/gitHistoryHandle.ts (1 hunks)
src/core/output/outputGenerate.ts (7 hunks)
src/core/output/outputGeneratorTypes.ts (3 hunks)
src/core/output/outputStyles/markdownStyle.ts (1 hunks)
src/core/output/outputStyles/xmlStyle.ts (1 hunks)
src/core/packager.ts (4 hunks)
tests/cli/actions/workers/defaultActionWorker.test.ts (1 hunks)
tests/config/configSchema.test.ts (2 hunks)
tests/core/git/gitHistory.test.ts (1 hunks)
tests/core/metrics/calculateGitDiffMetrics.test.ts (1 hunks)
tests/core/metrics/calculateGitLogMetrics.test.ts (1 hunks)
tests/core/output/diffsInOutput.test.ts (2 hunks)
tests/core/output/flagFullDirectoryStructure.test.ts (3 hunks)
tests/core/output/outputGenerate.test.ts (2 hunks)
tests/core/output/outputGenerateDiffs.test.ts (5 hunks)
tests/core/output/outputStyles/jsonStyle.test.ts (1 hunks)
tests/core/packager.test.ts (1 hunks)
website/client/.vitepress/config/configEnUs.ts (1 hunks)
website/client/src/en/guide/command-line-options.md (2 hunks)
website/client/src/en/guide/configuration.md (1 hunks)
website/client/src/en/guide/output.md (1 hunks)
website/client/src/en/guide/tips/git-commit-history.md (1 hunks)
website/client/src/en/guide/usage.md (1 hunks)

🧰 Additional context used

🧬 Code graph analysis (4)

src/core/output/outputGeneratorTypes.ts (1)

src/core/git/gitHistoryHandle.ts (1)

GitHistoryResult (34-38)

tests/core/git/gitHistory.test.ts (1)

src/core/git/gitHistory.ts (5)

parseCommitRange (59-85)

getCommitMetadata (90-183)

getTags (252-282)

getCommitPatch (287-327)

getCommitGraph (188-247)

src/core/output/outputGenerate.ts (1)

src/core/git/gitHistoryHandle.ts (1)

GitHistoryResult (34-38)

tests/core/output/diffsInOutput.test.ts (1)

src/core/output/outputGenerate.ts (1)

generateOutput (255-298)

🔇 Additional comments (42)

tests/core/output/outputStyles/jsonStyle.test.ts (1)

34-39: LGTM! Test configuration properly extended.

The git history config fields are correctly added to the test mock with appropriate defaults that align with the new feature design.

tests/core/metrics/calculateGitLogMetrics.test.ts (1)

52-57: LGTM! Consistent test config update.

Git history configuration fields properly added, maintaining consistency with the expanded schema and other test files.

website/client/src/en/guide/output.md (1)

244-286: Excellent documentation of the new commit history feature.

The section clearly explains the XML structure, patch detail levels, and provides practical guidance for users. The examples are well-formatted and the explanations are concise.

website/client/src/en/guide/command-line-options.md (2)

61-72: Well-documented CLI options.

The new git commit history options are clearly explained with appropriate detail levels and semantic descriptions. The placement and formatting align with existing documentation patterns.

119-124: Great example usage patterns.

The examples effectively demonstrate common scenarios for the new git commit history feature, from basic usage to advanced configurations.

website/client/.vitepress/config/configEnUs.ts (1)

48-48: LGTM! Navigation entry properly added.

The new guide link is appropriately placed in the Advanced section and follows the existing navigation structure.

tests/core/output/outputGenerateDiffs.test.ts (1)

89-90: LGTM! Consistent API signature updates.

All generateOutput call sites properly updated with the new optional parameters. The inline comments clearly indicate the purpose of each undefined parameter, maintaining good code readability.

Also applies to: 123-125, 158-160, 193-195, 238-240

tests/core/output/flagFullDirectoryStructure.test.ts (2)

34-39: LGTM! Test configuration properly extended.

Git history fields added consistently with the expanded schema and other test files.

80-80: LGTM! Function signatures correctly updated.

The buildOutputGeneratorContext calls properly include the new optional parameter, maintaining backward compatibility with undefined.

Also applies to: 113-113

src/core/output/outputStyles/xmlStyle.ts (1)

83-145: Excellent template implementation.

The new git_history block is well-structured and follows existing Handlebars patterns in the file. The comprehensive structure properly handles:

Conditional rendering with appropriate guards

Nested optional fields (mermaid_graph, tags, patch)

Proper attribute and element hierarchy

Consistent formatting with the rest of the template

The template correctly uses triple braces for unescaped content, which is appropriate for pre-formatted git data.

tests/core/output/outputGenerate.test.ts (1)

44-53: Tests correctly updated for new gitHistoryResult parameter

The extra undefined arguments in both generateOutput and buildOutputGeneratorContext calls match the extended core signature and preserve existing behavior; mocks and expectations remain consistent with the new API.

Also applies to: 55-64

tests/core/output/diffsInOutput.test.ts (1)

126-141: generateOutput mocks aligned with extended signature

Both test cases now pass gitDiffResult, gitLogResult (undefined), and gitHistoryResult (undefined) before the deps object, which matches the updated generateOutput function signature and keeps the diff-focused assertions intact.

Also applies to: 199-214

tests/core/packager.test.ts (1)

90-98: Packager test correctly mirrors new generateOutput arity

The additional undefined in the generateOutput expectation matches the new gitHistoryResult argument, keeping the pack orchestration test in sync with the core output API.

tests/core/metrics/calculateGitDiffMetrics.test.ts (1)

46-58: Mock config extended to cover new git history fields without affecting diff tests

Including the git commit history options on mockConfig.output.git keeps this test aligned with the expanded schema while leaving the git diff metrics behavior unchanged, since none of these new fields are consumed by calculateGitDiffMetrics.

src/core/output/outputStyles/markdownStyle.ts (1)

79-142: Git commit history Markdown template is structurally sound

The new gitCommitHistoryEnabled block cleanly renders summary, optional graph/tags, and per-commit details with appropriate Handlebars conditionals and Markdown fencing, and it composes safely with existing git diff/log sections.

README.md (1)

289-306: Commit history CLI docs are consistent with new options

The new README sections accurately describe --include-commit-history, --commit-range, --commit-patch-detail, and the --no-commit-* flags, including defaults and intended behavior, and they line up with the CLI option names introduced in code.

Also applies to: 653-658

src/cli/cliRun.ts (1)

16-49: CLI wiring for git commit history options looks correct

The semantic suggestion entries for git-commits, commit-range, and history match the cleaned option keys, and the new commit history flags are defined with clear help text and Commander-friendly --no-* semantics that align with the documented behavior.

Also applies to: 143-155

src/cli/actions/defaultAction.ts (1)

283-307: Git commit history CLI options are merged into config safely

The new buildCliConfig block merges commit history–related CLI flags into output.git without clobbering existing git settings, and it respects the “only override when explicitly set (especially for --no-* flags)” convention used elsewhere in this function.

website/client/src/en/guide/usage.md (1)

120-145: Excellent documentation structure and examples.

The commit history analysis section is clear, well-organized, and provides practical examples that progress from simple to advanced use cases. The reference to the detailed guide is helpful.

src/core/packager.ts (2)

109-111: Clean integration following established patterns.

The git history retrieval is correctly positioned before security checks and follows the same pattern as getGitDiffs and getGitLogs. The progress callback message is clear and consistent.

127-127: Proper threading of git history through the pipeline.

The gitHistoryResult parameter is correctly added to the generateOutput call, maintaining parameter order consistency with the function signature.

src/cli/types.ts (1)

30-36: Well-typed CLI options with clear documentation.

The new git commit history options are properly typed, especially the union type for commitPatchDetail. The comments explaining the negative flag behavior (lines 34-36) are helpful for understanding how --no-commit-graph and similar flags work.

src/core/output/outputGeneratorTypes.ts (1)

4-4: Type-safe integration with proper optional handling.

The type extensions correctly use GitHistoryResult['field'] syntax to extract specific types, ensuring consistency with the source type definition. Making all fields optional properly supports the feature being disabled.

Also applies to: 15-15, 39-42

tests/cli/actions/workers/defaultActionWorker.test.ts (1)

62-67: Test fixture properly updated with correct defaults.

The mock configuration includes all new git history fields with values matching the documented defaults. Good use of as const for commitPatchDetail to ensure type safety in tests.

tests/core/git/gitHistory.test.ts (5)

10-64: Comprehensive test coverage for parseCommitRange.

Tests cover multiple range formats (HEAD, tags, branches), single commit shorthand, whitespace handling, and error cases (empty, invalid format). Well-structured and thorough.

66-145: Thorough testing of getCommitMetadata with edge cases.

Tests validate full metadata parsing including multi-parent commits, author/committer details, message/body separation, and file lists. Good coverage of the initial commit edge case (no parents) and error handling.

147-189: Complete getTags test coverage with error resilience.

Tests verify tag parsing, empty results, and graceful error handling. The error case properly returns an empty object rather than throwing, which is the correct resilient behavior.

191-279: Excellent verification of all patch detail levels.

Tests cover all four detail levels (full, stat, files, metadata) and verify the correct git arguments are passed for each. Good inclusion of error case for invalid detail level.

281-333: Well-structured integration test for getCommitGraph.

The test properly mocks sequential git operations and validates the composite workflow including graph visualization, commit metadata, and tag mapping. Good assertions on commits length, graph content, mermaidGraph presence, and tags.

llms-install.md (1)

64-66: LGTM!

The new git commit history parameters are well-documented with accurate defaults matching the schema definitions. The descriptions clearly explain each option's purpose and accepted values.

src/config/configSchema.ts (2)

51-57: LGTM!

The new git commit history configuration options are well-structured and follow the existing pattern. The commitPatchDetail enum provides clear validation, and the optional nature of all fields maintains backward compatibility.

117-123: LGTM!

Sensible defaults: includeCommitHistory: false ensures opt-in behavior, while the sub-options default to true to provide comprehensive output when enabled. The default range of HEAD~50..HEAD is a reasonable scope for most analysis use cases.

src/core/git/gitHistoryHandle.ts (2)

43-51: LGTM!

Good use of dependency injection for testability. The function signature with optional deps parameter allows easy mocking in tests.

128-134: LGTM!

Proper error handling: re-throws RepomixError instances directly while wrapping unknown errors with context and original cause.

tests/config/configSchema.test.ts (2)

124-129: LGTM!

Test values correctly match the schema defaults. Good coverage for the new git history configuration options.

235-240: LGTM!

Consistent test coverage for the merged schema with the same expected values.

src/core/output/outputGenerate.ts (3)

59-62: LGTM!

Render context fields correctly expose git history data with appropriate undefined handling via optional chaining and nullish coalescing.

160-188: LGTM!

The JSON output structure for gitCommitHistory is comprehensive, including summary, graph components, and per-commit metadata with optional patches. The conditional spread operators correctly handle optional fields.

255-282: LGTM!

The function signature extension with gitHistoryResult parameter maintains backward compatibility via default undefined value, and the parameter is correctly propagated through the context builder.

src/core/git/gitHistory.ts (3)

59-85: LGTM!

The range parsing handles both single commit and range formats cleanly. The single commit conversion to commit^..commit is a reasonable approach.

252-282: LGTM!

Graceful error handling returns an empty object instead of throwing, which is appropriate for optional tag information.

287-327: LGTM!

Clean implementation with proper handling of all detail levels. The exhaustive switch with a default error case ensures invalid values are caught.

src/core/git/gitHistory.ts

website/client/src/en/guide/configuration.md

gemini-code-assist

Code Review

This pull request introduces a comprehensive git commit history analysis feature, which is a great addition for understanding code evolution. The implementation is thorough, covering CLI options, configuration, core logic, output generation, testing, and documentation. However, I've identified a few critical issues in the implementation that could lead to incorrect data parsing and invalid XML output. I've also found a minor issue with the Mermaid graph generation. My review includes specific suggestions to address these points and improve the feature's robustness.

src/core/git/gitHistory.ts

src/core/output/outputStyles/xmlStyle.ts

src/core/git/gitHistory.ts

ahundt · 2025-11-25T20:01:45Z

Hey, I addressed the ai-generated review feedback in the latest commit:

Fixed:

Body/file parsing now uses %x00 null byte delimiter instead of the fragile heuristic. Null bytes can't appear in commit messages or file paths, so this reliably separates them.
Mermaid gitGraph syntax corrected. Was using invalid merge <hash>, now uses proper commit id: "..." tag: "..." type: HIGHLIGHT.
Added git_history section to parsable XML output to match JSON structure.
Added includeCommitPatches to configuration docs.
Added files list to XML (<files>) and Markdown (**Files Changed**) templates.

Kept as-is:

--all flag stays. It's git's standard flag for showing branch topology within the specified range. Documented this behavior.

Out of scope:

CDATA wrapping: The existing XML templates don't use it, so adding it just for commit history would be inconsistent. Parsable XML uses XMLBuilder which escapes automatically.
Parallel patch fetching: Overkill for this functionality. Sequential is simpler and avoids spawning many git processes.

894 tests passing, lint clean. Let me know if you'd like any changes! Thanks for the useful tool!

ahundt · 2025-11-26T11:26:38Z

@yamadashy this seems to be in reasonably good shape now if you're up for giving it a look! The summary at the very top should be up to date now.

/gemini review

@coderabbitai full review

coderabbitai · 2025-11-26T11:27:00Z

@ahundt, thank you for the comprehensive updates and for addressing the previous feedback! I can see you've made thoughtful improvements:

✅ Robust parsing with null byte delimiters
✅ Correct Mermaid syntax for git graphs
✅ Complete XML/JSON parity with the new git_history section
✅ Enhanced documentation and template coverage
✅ Strong test coverage (894 tests passing, lint clean)

Your decisions on keeping --all and deferring CDATA/parallel fetching are reasonable given the context and consistency with the existing codebase.

I'll perform a full review of the entire PR now to provide comprehensive feedback on the implementation.

✅ Actions performed

Full review triggered.

gemini-code-assist · 2025-11-26T11:28:10Z

Hello @ahundt,

Thank you for the detailed update and for addressing the feedback from the previous review. I appreciate the thoroughness of your changes and the clear explanations for the decisions made.

I've reviewed the latest commit, and the fixes you've implemented are excellent:

Null Byte Delimiter: The adoption of %x00 for robust parsing of commit metadata and file lists is a significant improvement. This eliminates the fragility of previous heuristics and ensures reliable data extraction, even with unusual commit messages or file paths.
Mermaid GitGraph Syntax: The correction to use commit id: "..." tag: "..." type: HIGHLIGHT is spot on. This ensures compatibility with Mermaid and correctly visualizes merge commits and tags.
XML Output Structure: The git_history section has been correctly integrated into the parsable XML output, aligning it with the JSON structure and providing a consistent, rich data representation.
Configuration Documentation: includeCommitPatches is now properly documented in llms-install.md and website/client/src/en/guide/configuration.md.
Files List in Templates: The inclusion of the files list in both XML and Markdown templates for commit history is a valuable addition, providing a complete picture of each commit's changes.

Your decision to keep the --all flag for git log and to document its behavior is reasonable, as it aligns with standard Git functionality for showing branch topology. Similarly, your rationale for not implementing CDATA wrapping (due to existing XML templates and automatic escaping) and parallel patch fetching (for simplicity and avoiding process overhead) is well-justified.

The new two-pass architecture for Git log parsing, along with the dedicated modules for Git operations (gitCommand.ts, gitHistory.ts, gitLogHandle.ts), significantly enhances the robustness, maintainability, and flexibility of the Git history feature. The comprehensive test suite, especially gitHistory.test.ts, demonstrates a strong commitment to quality and covers various scenarios and edge cases.

Overall, this is a very well-executed enhancement. Great work!

I will now proceed with a full review as requested by /gemini review.

coderabbitai

Actionable comments posted: 5

🧹 Nitpick comments (13)

tests/core/metrics/calculateGitDiffMetrics.test.ts (1)

46-58: Mock config now mirrors extended git options; consider centralizing

Adding commitRange, commitPatchDetail, includeCommitGraph, includeSummary, includeGitTags, and includeCommitPatches keeps this mock aligned with the real config shape, even though calculateGitDiffMetrics doesn’t use them directly.
To reduce drift as more git options are added, consider extracting a shared createMockConfig() factory used across metrics/git tests instead of inlining these defaults here.

website/client/src/fr/guide/command-line-options.md (1)

61-78: Git commit history options section is accurate; only minor FR style nits

The new section correctly mirrors the CLI behavior (diff format flags vs graph/detail options and the --commit-range syntax). For style, you might optionally tweak wording to be more idiomatic French, e.g.:

Heading: ## Options de l’historique des commits Git (lowercase “historique” and “commits”).

“Ces flags indépendants…” → “Ces indicateurs indépendants…” if you want to avoid the anglicism flags.

“les hashes SHA” → “les hachages SHA” for more standard French.

Purely stylistic; the current text is understandable and technically correct.

website/client/src/ko/guide/command-line-options.md (1)

61-78: Korean git history options read clearly; optional wording tweak

The section accurately documents the diff-format flags and the graph/detail options, including the default HEAD~50..HEAD range and .. / ... syntax. If you want slightly more natural Korean, consider replacing “직교 플래그들은” with “독립적인 플래그들은” or similar, which may read more intuitively than the mathematical “직교” for most readers.

src/core/metrics/calculateGitLogMetrics.ts (1)

22-37: Updated token counting for structured git logs is sound; consider including all rendered pieces

Using logCommits plus the optional graph.graph to build logContent and adding an explicit guard for “no commits” is a good adaptation to the new structured GitLogResult. Two follow-ups you might consider:

If the rendered output also includes additional git history strings (e.g., a separate Mermaid graph or a textual summary/tags section), you may want to concatenate those into logContent as well so gitLogTokenCount reflects everything actually emitted.

With the logCommits.length === 0 guard and JSON.stringify, the if (!logContent) check becomes effectively redundant; you could simplify by relying on the earlier guard, though it’s harmless as-is.

These are small refinements; the current implementation is correct for non-empty logCommits.

Also applies to: 47-48
website/client/src/pt-br/guide/command-line-options.md (1)
61-79: Minor PT-BR wording tweak for naturalness

Frase inicial pode soar um pouco estranha em PT-BR (“Esses flags…”). Sugestão leve:
- Esses flags independentes espelham a estrutura do git log para controle detalhado:
+ Essas flags independentes espelham a estrutura do git log para controle detalhado:
Os avisos de “pontuação duplicada” do analisador vêm do uso legítimo de intervalos git (HEAD~50..HEAD, main...feature-branch), então não vejo necessidade de alteração aí.
README.md (1)

289-310: Git history examples and options are strong; consider clarifying flag interaction

The new examples and option descriptions for --commit-range, diff format flags, --graph, and --summary look consistent with the PR’s design and give users a good mental model of “orthogonal” git history controls.

One thing that might be worth spelling out explicitly:

How --include-logs-count interacts with --commit-range when both are provided (e.g., does the explicit commit range override the count, are both applied, or is one ignored?).

Whether the default --include-logs-count and the default commit range HEAD~50..HEAD are intended to be strictly equivalent, or if they differ in edge cases.

A short note in this README section (and/or the CLI docs) about precedence would help avoid user confusion once people start composing these flags.

Also applies to: 657-672

tests/core/output/outputStyles/jsonStyle.test.ts (1)

28-40: Git config test defaults updated; consider tying them to schema defaults

Extending the mock output.git block with commitRange, commitPatchDetail, includeCommitGraph, includeSummary, includeGitTags, and includeCommitPatches looks correct for the expanded RepomixConfigMerged type and keeps this test compiling.

To reduce future drift, you might consider deriving these values from the actual config defaults (e.g., via a shared helper or factory) rather than hard-coding them here, so tests continue to mirror real-world default behavior if the schema changes.
src/core/security/securityCheck.ts (1)
49-64: Consider scanning mermaidGraph content as well.

The security check scans gitLogResult.graph.graph (ASCII graph) but not gitLogResult.graph.mermaidGraph. Since Mermaid graphs may also contain commit messages that could leak sensitive data, consider adding it to the scan.
     // Check commit graph visualization if available
     if (gitLogResult.graph) {
       gitLogTasks.push({
         filePath: 'Git commit graph',
         content: gitLogResult.graph.graph,
         type: 'gitLog',
       });
+      if (gitLogResult.graph.mermaidGraph) {
+        gitLogTasks.push({
+          filePath: 'Git commit mermaid graph',
+          content: gitLogResult.graph.mermaidGraph,
+          type: 'gitLog',
+        });
+      }
     }
website/client/src/es/guide/command-line-options.md (1)
117-124: Missing git history examples compared to English documentation.

The English documentation includes new examples for git commit history analysis (lines 126-134 in EN version) demonstrating --patch, --graph, --summary, and --commit-range usage. Consider adding the equivalent examples to maintain parity.

Add the following examples after Line 124:
# Análisis del historial de commits de Git con flags independientes
repomix --include-logs  # Log simple de commits (formato name-only por defecto)
repomix --include-logs --patch  # Diffs línea por línea
repomix --include-logs --graph  # Con visualización de gráfico de commits
repomix --include-logs --patch --graph --summary  # Análisis completo
repomix --include-logs --commit-range "v1.0..HEAD"  # Rango específico (dos puntos)
repomix --include-logs --commit-range "main...feature"  # Diff simétrico (tres puntos)
repomix --include-logs --stat --graph -o analysis.xml  # Análisis completo a archivo
src/core/git/gitCommand.ts (1)

243-255: Consider whether --all flag should be configurable.

The execGitGraph function hardcodes --all which shows commits from all branches. This may include unrelated branches in the visualization when users only want to see commits in a specific range.

Based on the PR comments mentioning "Documented and retained --all flag behavior", this appears to be intentional. However, consider if this should be a configurable option for users who want branch-scoped graphs.

src/core/git/gitLogHandle.ts (2)

112-117: Patch-to-commit matching relies on array index alignment.

The patches are matched to commits by array index (patches[commits.length] at line 192). This assumes execGitLogTextBlob returns patches in the exact same order as execGitLogStructured returns commits. While this should be true when using the same range/maxCommits parameters, if the two git commands ever produce different commit counts (e.g., due to timing or edge cases), patches could be misaligned.

Consider adding a defensive check or log warning if patches.length !== commits.length after parsing, to catch potential mismatches during development/debugging.

246-253: Type assertion could allow invalid values.

The as 'patch' | 'stat' | 'shortstat' | 'dirstat' | 'numstat' assertion at line 251 doesn't include all valid PatchDetailLevel values from the schema (missing 'raw', 'name-only', 'name-status'). While the patchTypes.includes() check filters which values reach here, the assertion doesn't fully match PatchDetailLevel.

Consider using the PatchDetailLevel type directly or validating the value before the assertion.
src/core/git/gitHistory.ts (1)
81-86: Edge case: Range with multiple .. sequences.

If a range string contains multiple .. (e.g., user error like HEAD~10..HEAD..main), split('..') will return more than two parts, and only the first two will be used. The function won't report an error for this malformed input.

Consider adding validation for exactly two parts:
   // Handle range formats
   const [from, to] = range.split('..');
+  const parts = range.split('..');
+  if (parts.length !== 2) {
+    throw new RepomixError(`Invalid commit range format: '${range}'. Expected exactly one '..' separator`);
+  }
+  const [from, to] = parts;

   if (!from || !to) {
     throw new RepomixError(`Invalid commit range format: '${range}'. Expected format: 'from..to'`);
   }

📜 Review details

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 3b83f9c and 3b8412a.

⛔ Files ignored due to path filters (1)

package-lock.json is excluded by !**/package-lock.json

📒 Files selected for processing (44)

.gitignore (1 hunks)
README.md (2 hunks)
llms-install.md (2 hunks)
src/cli/actions/defaultAction.ts (1 hunks)
src/cli/cliRun.ts (2 hunks)
src/cli/types.ts (1 hunks)
src/config/configSchema.ts (2 hunks)
src/core/git/gitCommand.ts (1 hunks)
src/core/git/gitHistory.ts (1 hunks)
src/core/git/gitLogHandle.ts (2 hunks)
src/core/metrics/calculateGitLogMetrics.ts (2 hunks)
src/core/output/outputGenerate.ts (4 hunks)
src/core/output/outputGeneratorTypes.ts (1 hunks)
src/core/output/outputStyles/markdownStyle.ts (1 hunks)
src/core/output/outputStyles/xmlStyle.ts (2 hunks)
src/core/packager.ts (1 hunks)
src/core/security/securityCheck.ts (1 hunks)
tests/cli/actions/workers/defaultActionWorker.test.ts (1 hunks)
tests/config/configSchema.test.ts (2 hunks)
tests/core/git/gitHistory.test.ts (1 hunks)
tests/core/git/gitLogHandle.test.ts (11 hunks)
tests/core/metrics/calculateGitDiffMetrics.test.ts (1 hunks)
tests/core/metrics/calculateGitLogMetrics.test.ts (19 hunks)
tests/core/output/flagFullDirectoryStructure.test.ts (1 hunks)
tests/core/output/outputGenerate.test.ts (2 hunks)
tests/core/output/outputGenerateDiffs.test.ts (5 hunks)
tests/core/output/outputStyles/jsonStyle.test.ts (1 hunks)
website/client/.vitepress/config/configEnUs.ts (1 hunks)
website/client/src/de/guide/command-line-options.md (1 hunks)
website/client/src/en/guide/command-line-options.md (2 hunks)
website/client/src/en/guide/configuration.md (3 hunks)
website/client/src/en/guide/output.md (1 hunks)
website/client/src/en/guide/tips/git-commit-history.md (1 hunks)
website/client/src/en/guide/usage.md (1 hunks)
website/client/src/es/guide/command-line-options.md (1 hunks)
website/client/src/fr/guide/command-line-options.md (1 hunks)
website/client/src/hi/guide/command-line-options.md (1 hunks)
website/client/src/id/guide/command-line-options.md (1 hunks)
website/client/src/ja/guide/command-line-options.md (1 hunks)
website/client/src/ko/guide/command-line-options.md (1 hunks)
website/client/src/pt-br/guide/command-line-options.md (1 hunks)
website/client/src/vi/guide/command-line-options.md (1 hunks)
website/client/src/zh-cn/guide/command-line-options.md (1 hunks)
website/client/src/zh-tw/guide/command-line-options.md (1 hunks)

🧰 Additional context used

🧬 Code graph analysis (7)

src/cli/actions/defaultAction.ts (1)

src/shared/errorHandle.ts (1)

RepomixError (6-11)

src/core/git/gitCommand.ts (1)

src/shared/logger.ts (1)

error (34-38)

src/core/git/gitLogHandle.ts (4)

src/core/git/gitHistory.ts (3)

PatchDetailLevel (53-61)

CommitGraph (33-39)

CommitMetadata (11-28)

src/config/configSchema.ts (1)

RepomixConfigMerged (173-173)

src/shared/logger.ts (1)

error (34-38)

src/shared/errorHandle.ts (1)

RepomixError (6-11)

tests/core/git/gitHistory.test.ts (1)

src/core/git/gitHistory.ts (5)

parseCommitRange (67-93)

getCommitMetadata (102-187)

getTags (256-286)

getCommitPatch (291-353)

getCommitGraph (192-251)

tests/core/metrics/calculateGitLogMetrics.test.ts (1)

src/core/git/gitLogHandle.ts (1)

GitLogResult (37-41)

src/core/output/outputGeneratorTypes.ts (1)

src/core/git/gitLogHandle.ts (1)

GitLogResult (37-41)

tests/core/output/outputGenerate.test.ts (2)

tests/testing/testUtils.ts (1)

createMockConfig (15-45)

src/core/output/outputGenerate.ts (1)

generateOutput (294-335)

🪛 LanguageTool

website/client/src/fr/guide/command-line-options.md

[grammar] ~61-~61: «  historique  » semble plus probable dans ce contexte
Context: ...'intégration d'outils IA ## Options de l'Historique des Commits Git Ces flags indépendants...

(QB_NEW_FR_OTHER_ERROR_IDS_REPLACEMENT_ORTHOGRAPHY_UPPERCASE)

[grammar] ~61-~61: «  commits  » semble plus probable dans ce contexte
Context: ...tils IA ## Options de l'Historique des Commits Git Ces flags indépendants reflètent l...

(QB_NEW_FR_OTHER_ERROR_IDS_REPLACEMENT_ORTHOGRAPHY_UPPERCASE)

[grammar] ~63-~63: Il y a peut-être une erreur ici
Context: ...a structure de git log pour un contrôle précis : Flags de Format de Diff (mutuellement ...

(QB_NEW_FR)

[grammar] ~65-~65: «  format  » semble plus probable dans ce contexte
Context: ...g pour un contrôle précis : Flags de Format de Diff (mutuellement exclusifs - cho...

(QB_NEW_FR_OTHER_ERROR_IDS_REPLACEMENT_ORTHOGRAPHY_UPPERCASE)

[grammar] ~65-~65: «  diff  » semble plus probable dans ce contexte
Context: ...contrôle précis : Flags de Format de Diff (mutuellement exclusifs - choisissez-...

(QB_NEW_FR_OTHER_ERROR_IDS_REPLACEMENT_ORTHOGRAPHY_UPPERCASE)

[grammar] ~65-~65: Il y a peut-être une erreur ici
Context: ...Flags de Format de Diff** (mutuellement exclusifs - choisissez-en un) : - --stat : Affic...

(QB_NEW_FR)

[typographical] ~65-~65: Le trait d’union est employé sans espace pour former des mots, alors que le tiret est encadré par des espaces et placé entre deux mots distincts.
Context: ...ormat de Diff** (mutuellement exclusifs - choisissez-en un) : - --stat : Affich...

(TIRET)

[grammar] ~65-~65: Il y a peut-être une erreur ici
Context: ...mat de Diff** (mutuellement exclusifs - choisissez-en un) : - --stat : Afficher le nombre...

(QB_NEW_FR)

[grammar] ~65-~65: Il y a peut-être une erreur ici
Context: ...tuellement exclusifs - choisissez-en un) : - --stat : Afficher le nombre de mod...

(QB_NEW_FR)

[grammar] ~65-~65: Envisagez un remplacement
Context: ...ellement exclusifs - choisissez-en un) : - --stat : Afficher le nombre de modifications par...