benchmark-action · ankitml · Dec 19, 2025 · Dec 19, 2025 · Dec 19, 2025 · Dec 22, 2025
diff --git a/src/addBenchmarkEntry.ts b/src/addBenchmarkEntry.ts
@@ -2,6 +2,7 @@ import { Benchmark } from './extract';
 import * as core from '@actions/core';
 import { BenchmarkSuites } from './write';
 import { normalizeBenchmark } from './normalizeBenchmark';
+import { GitGraphAnalyzer } from './gitGraph';
 
 export function addBenchmarkEntry(
     benchName: string,
@@ -11,24 +12,32 @@ export function addBenchmarkEntry(
 ): { prevBench: Benchmark | null; normalizedCurrentBench: Benchmark } {
     let prevBench: Benchmark | null = null;
     let normalizedCurrentBench: Benchmark = benchEntry;
+    const gitAnalyzer = new GitGraphAnalyzer();
 
     // Add benchmark result
     if (entries[benchName] === undefined) {
         entries[benchName] = [benchEntry];
         core.debug(`No suite was found for benchmark '${benchName}' in existing data. Created`);
     } else {
         const suites = entries[benchName];
-        // Get the last suite which has different commit ID for alert comment
-        for (const e of [...suites].reverse()) {
-            if (e.commit.id !== benchEntry.commit.id) {
-                prevBench = e;
-                break;
-            }
+
+        // Find previous benchmark using git ancestry
+        core.debug(`Finding previous benchmark for commit: ${benchEntry.commit.id}`);
+
+        prevBench = gitAnalyzer.findPreviousBenchmark(suites, benchEntry.commit.id);
+
+        if (prevBench) {
+            core.debug(`Found previous benchmark: ${prevBench.commit.id}`);
+        } else {
+            core.debug('No previous benchmark found');
         }
 
         normalizedCurrentBench = normalizeBenchmark(prevBench, benchEntry);
 
-        suites.push(normalizedCurrentBench);
+        // Insert at the correct position based on git ancestry
+        const insertionIndex = gitAnalyzer.findInsertionIndex(suites, benchEntry.commit.id);
+        core.debug(`Inserting benchmark at index ${insertionIndex} (of ${suites.length} existing entries)`);
+        suites.splice(insertionIndex, 0, normalizedCurrentBench);
 
         if (maxItems !== null && suites.length > maxItems) {
             suites.splice(0, suites.length - maxItems);

diff --git a/src/config.ts b/src/config.ts
@@ -4,6 +4,7 @@ import * as os from 'os';
 import * as path from 'path';
 
 export type ToolType = typeof VALID_TOOLS[number];
+
 export interface Config {
     name: string;
     tool: ToolType;

diff --git a/src/default_index_html.ts b/src/default_index_html.ts
@@ -161,11 +161,14 @@ export const DEFAULT_INDEX_HTML = String.raw`<!DOCTYPE html>
             a.click();
           };
 
-          // Prepare data points for charts
-          return Object.keys(data.entries).map(name => ({
-            name,
-            dataSet: collectBenchesPerTestCase(data.entries[name]),
-          }));
+          // Prepare data points for charts (uses server-side ordering)
+          return Object.keys(data.entries).map(name => {
+            const entries = data.entries[name];
+            return {
+              name,
+              dataSet: collectBenchesPerTestCase(entries),
+            };
+          });
         }
 
         function renderAllChars(dataSets) {

diff --git a/src/gitGraph.ts b/src/gitGraph.ts
@@ -0,0 +1,154 @@
+import { spawnSync } from 'child_process';
+import * as core from '@actions/core';
+import { Benchmark } from './extract';
+
+export class GitGraphAnalyzer {
+    private readonly gitCliAvailable: boolean;
+
+    constructor() {
+        try {
+            spawnSync('git', ['--version'], { stdio: 'ignore' });
+            this.gitCliAvailable = true;
+        } catch (e) {
+            this.gitCliAvailable = false;
+            core.debug('Git CLI not available during initialization');
+        }
+    }
+
+    /**
+     * Check if git CLI is available
+     */
+    isGitAvailable(): boolean {
+        return this.gitCliAvailable;
+    }
+
+    /**
+     * Validate that a ref matches expected git reference patterns.
+     * Accepts SHA hashes, branch names, and tag names.
+     */
+    private isValidRef(ref: string): boolean {
+        if (!ref || ref.length === 0) {
+            return false;
+        }
+        // Allow: hex SHA (short or full), branch/tag names (alphanumeric, dots, underscores, hyphens, slashes)
+        const validRefPattern = /^[a-zA-Z0-9._\-/]+$/;
+        return validRefPattern.test(ref);
+    }
+
+    /**
+     * Get git ancestry using topological order
+     */
+    getAncestry(ref: string): string[] {
+        if (!this.gitCliAvailable) {
+            core.warning('Git CLI not available, cannot determine ancestry');
+            return [];
+        }
+
+        if (!this.isValidRef(ref)) {
+            core.warning(`Invalid git ref format: ${ref}`);
+            return [];
+        }
+
+        try {
+            const result = spawnSync('git', ['log', '--oneline', '--topo-order', ref], {
+                encoding: 'utf8',
+                cwd: process.env.GITHUB_WORKSPACE ?? process.cwd(),
+            });
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            return result.stdout
+                .split('\n')
+                .filter((line) => line.trim())
+                .map((line) => line.split(' ')[0]); // Extract SHA from "sha message"
+        } catch (error) {
+            core.warning(`Failed to get ancestry for ref ${ref}: ${error}`);
+            return [];
+        }
+    }
+
+    /**
+     * Find previous benchmark commit based on git ancestry.
+     * Falls back to execution time ordering if git ancestry is not available.
+     */
+    findPreviousBenchmark(suites: Benchmark[], currentSha: string): Benchmark | null {
+        const ancestry = this.getAncestry(currentSha);
+
+        if (ancestry.length === 0) {
+            core.warning(`No ancestry found for commit ${currentSha}, falling back to execution time ordering`);
+            return this.findPreviousByExecutionTime(suites, currentSha);
+        }
+
+        // Find position of current commit in ancestry
+        const currentIndex = ancestry.indexOf(currentSha);
+        if (currentIndex === -1) {
+            core.warning(`Current commit ${currentSha} not found in ancestry, falling back to execution time ordering`);
+            return this.findPreviousByExecutionTime(suites, currentSha);
+        }
+
+        // Look for next commit in ancestry that exists in benchmarks
+        for (let i = currentIndex + 1; i < ancestry.length; i++) {
+            const previousSha = ancestry[i];
+            const previousBenchmark = suites.find((suite) => suite.commit.id === previousSha);
+
+            if (previousBenchmark) {
+                core.debug(`Found previous benchmark: ${previousSha} based on git ancestry`);
+                return previousBenchmark;
+            }
+        }
+
+        // Fallback: no previous commit found in ancestry
+        core.debug('No previous benchmark found in git ancestry');
+        return null;
+    }
+
+    /**
+     * Find the insertion index for a new benchmark entry based on git ancestry.
+     * Inserts after the most recent ancestor in the existing suites.
+     */
+    findInsertionIndex(suites: Benchmark[], newCommitSha: string): number {
+        if (!this.gitCliAvailable || suites.length === 0) {
+            return suites.length;
+        }
+
+        const ancestry = this.getAncestry(newCommitSha);
+        if (ancestry.length === 0) {
+            core.debug('No ancestry found, appending to end');
+            return suites.length;
+        }
+
+        // Create a set of ancestor SHAs for quick lookup (excluding the commit itself)
+        // Skip first element only if it matches the commit (it should)
+        const startIndex = ancestry[0] === newCommitSha ? 1 : 0;
+        const ancestorSet = new Set(ancestry.slice(startIndex));
+
+        // Find the most recent ancestor in the existing suites
+        // Iterate through suites from end to beginning to find the most recent one
+        for (let i = suites.length - 1; i >= 0; i--) {
+            const suite = suites[i];
+            if (ancestorSet.has(suite.commit.id)) {
+                core.debug(`Found ancestor ${suite.commit.id} at index ${i}, inserting after it`);
+                return i + 1; // Insert after this ancestor
+            }
+        }
+
+        // No ancestor found in existing suites - this commit is likely from a different branch
+        // or is very old. Append to end as fallback.
+        core.debug('No ancestor found in existing suites, appending to end');
+        return suites.length;
+    }
+
+    /**
+     * Fallback method: find previous by execution time (original logic)
+     */
+    private findPreviousByExecutionTime(suites: Benchmark[], currentSha: string): Benchmark | null {
+        for (const suite of [...suites].reverse()) {
+            if (suite.commit.id !== currentSha) {
+                return suite;
+            }
+        }
+        return null;
+    }
+}
diff --git a/src/write.ts b/src/write.ts
@@ -490,7 +490,7 @@ async function writeBenchmarkToExternalJson(
     jsonFilePath: string,
     config: Config,
 ): Promise<{ prevBench: Benchmark | null; normalizedCurrentBench: Benchmark }> {
-    const { name, maxItemsInChart, saveDataFile } = config;
+    const { name, saveDataFile, maxItemsInChart } = config;
     const data = await loadDataJson(jsonFilePath);
     const { prevBench, normalizedCurrentBench } = addBenchmarkToDataJson(name, bench, data, maxItemsInChart);