svn-visualizer 0.1.0

package/oxlint.config.ts

@@ -0,0 +1,36 @@
+import {linter as defaults} from './oxc.config.ts';
+
+// Add custom oxlint rule overrides here.
+// This file is preserved on template updates.
+//
+// Example:
+//   rules: { 'no-console': 'off' }
+//   overrides: [{ files: ['scripts/**'], rules: { 'no-console': 'off' } }]
+const rules = {
+	'eslint/func-style': 'off',
+	'typescript/promise-function-async': 'off',
+	'unicorn/max-nested-calls': ['warn', {max: 20}],
+};
+const overrides = [
+	{
+		files: ['src/client/**'],
+		env: {browser: true},
+		rules: {
+			'typescript/no-unsafe-type-assertion': 'off',
+		},
+	},
+	{
+		files: ['src/gather.ts'],
+		rules: {
+			'promise/avoid-new': 'off',
+		},
+	},
+];
+
+const config = {
+	...defaults,
+	rules: {...defaults.rules, ...rules},
+	overrides: [...defaults.overrides, ...overrides],
+};
+
+export default config;

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "svn-visualizer",
+  "version": "0.1.0",
+  "description": "Generate standalone HTML activity reports from Subversion history.",
+  "keywords": [
+    "charts",
+    "cli",
+    "reporting",
+    "subversion",
+    "svn",
+    "visualization"
+  ],
+  "homepage": "https://github.com/doberkofler/svn-visualizer#readme",
+  "bugs": {
+    "url": "https://github.com/doberkofler/svn-visualizer/issues"
+  },
+  "license": "MIT",
+  "author": "Dieter Oberkofler",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/doberkofler/svn-visualizer.git"
+  },
+  "bin": {
+    "svn-visualizer": "./dist/index.js"
+  },
+  "type": "module",
+  "dependencies": {
+    "chart.js": "4.5.1",
+    "commander": "15.0.0",
+    "debug": "4.4.3",
+    "fast-xml-parser": "5.11.1",
+    "fast-xml-validator": "1.4.2",
+    "zod": "4.6.5"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "21.2.3",
+    "@commitlint/config-conventional": "21.2.3",
+    "@types/debug": "4.1.13",
+    "@types/node": "26.6.2",
+    "@vitest/coverage-v8": "5.0.1",
+    "conventional-changelog": "8.1.3",
+    "conventional-changelog-angular": "9.4.0",
+    "eslint-plugin-regexp": "3.3.1",
+    "husky": "9.1.7",
+    "oxfmt": "0.70.0",
+    "oxlint": "1.85.0",
+    "oxlint-tsgolint": "7.0.2002",
+    "release-it": "21.1.0",
+    "typescript": "6.0.3",
+    "vite": "8.3.0",
+    "vitest": "5.0.1"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "create-template-project": {
+    "template": "cli"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint",
+    "format": "oxfmt --write",
+    "format:check": "oxfmt --check",
+    "ci": "pnpm run typecheck && pnpm run lint && pnpm run format:check && pnpm run build && pnpm run test",
+    "test": "vitest run --coverage",
+    "release": "release-it",
+    "create-changelog": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "svn-visualizer": "node dist/index.js",
+    "dev": "vite build --watch",
+    "build": "vite build --config vite.client.config.ts && vite build"
+  }
+}

package/src/aggregation.test.ts

@@ -0,0 +1,118 @@
+import {describe, expect, it} from 'vitest';
+import {aggregate, resolveRange} from './aggregation.js';
+import {type Commit} from './model.js';
+
+const commits: Commit[] = [
+	{revision: 1, author: 'ada', date: '2025-03-01T23:30:00.000Z', message: 'a'},
+	{revision: 2, author: 'ada', date: '2026-02-28T00:00:00.000Z', message: 'b'},
+	{revision: 3, author: null, date: '2026-03-01T01:00:00.000Z', message: 'c'},
+];
+
+describe('UTC date ranges and aggregation', () => {
+	it('uses deterministic relative UTC dates', () => {
+		expect(resolveRange(commits, {relativeDays: 30}, new Date('2026-03-01T23:59:59Z'))).toStrictEqual({from: '2026-01-31', to: '2026-03-01'});
+	});
+
+	it('rejects conflicts, invalid dates, and reversed dates', () => {
+		expect(() => resolveRange(commits, {from: '2026-01-01', relativeDays: 2})).toThrow('cannot be used');
+		expect(() => resolveRange(commits, {from: '2026-02-30'})).toThrow('Invalid UTC date');
+		expect(() => resolveRange(commits, {from: '2026-03-02', to: '2026-03-01'})).toThrow('after end date');
+		expect(() => resolveRange(commits, {relativeDays: 0})).toThrow('positive integer');
+	});
+
+	it('defaults to dataset bounds and today for empty data', () => {
+		expect(resolveRange(commits, {}, new Date('2030-01-01T00:00:00Z'))).toStrictEqual({from: '2025-03-01', to: '2026-03-01'});
+		expect(resolveRange([], {}, new Date('2026-04-05T22:00:00Z'))).toStrictEqual({from: '2026-04-05', to: '2026-04-05'});
+	});
+
+	it('produces UTC charts with exactly 30 days and 12 anchored months', () => {
+		const result = aggregate(commits, {from: '2025-03-01', to: '2026-03-01'});
+		expect(result.days.labels).toHaveLength(30);
+		expect(result.days.labels[0]).toBe('2026-01-31');
+		expect(result.days.labels.at(-1)).toBe('2026-03-01');
+		expect(result.months.labels).toHaveLength(12);
+		expect(result.months.labels).toStrictEqual([
+			'2025-04',
+			'2025-05',
+			'2025-06',
+			'2025-07',
+			'2025-08',
+			'2025-09',
+			'2025-10',
+			'2025-11',
+			'2025-12',
+			'2026-01',
+			'2026-02',
+			'2026-03',
+		]);
+		expect(result.weekdays.values.reduce((sum, count) => sum + count, 0)).toBe(3);
+		expect(result.hours.values[23]).toBe(1);
+		expect(result.users).toStrictEqual({labels: ['ada', '(no author)'], values: [2, 1]});
+	});
+
+	it('produces a stacked commits-per-day-and-user series over the same 30 days', () => {
+		const result = aggregate(commits, {from: '2025-03-01', to: '2026-03-01'});
+		expect(result.daysByUser.labels).toStrictEqual(result.days.labels);
+		expect(result.daysByUser.datasets).toHaveLength(2);
+		const ada = result.daysByUser.datasets.find((dataset) => dataset.label === 'ada');
+		const noAuthor = result.daysByUser.datasets.find((dataset) => dataset.label === '(no author)');
+		expect(ada?.values.reduce((sum, count) => sum + count, 0)).toBe(1);
+		expect(noAuthor?.values.reduce((sum, count) => sum + count, 0)).toBe(1);
+		expect(noAuthor?.values.at(-1)).toBe(1);
+	});
+
+	it('stacks the top-10 buckets for commits per day and user', () => {
+		const many = Array.from({length: 12}, (_, index) => ({
+			revision: index + 1,
+			author: `user${String(index).padStart(2, '0')}`,
+			date: '2026-03-01T00:00:00.000Z',
+			message: 'm',
+		}));
+		const result = aggregate(many, {from: '2026-03-01', to: '2026-03-01'});
+		expect(result.daysByUser.datasets).toHaveLength(11);
+		expect(result.daysByUser.datasets.map((dataset) => dataset.label)).toStrictEqual([
+			'user00',
+			'user01',
+			'user02',
+			'user03',
+			'user04',
+			'user05',
+			'user06',
+			'user07',
+			'user08',
+			'user09',
+			'(others)',
+		]);
+		const others = result.daysByUser.datasets.at(-1);
+		expect(others?.values.at(-1)).toBe(2);
+	});
+
+	it('caps contributors at 10 and buckets the remainder into "(others)"', () => {
+		const many = Array.from({length: 12}, (_, index) => ({
+			revision: index + 1,
+			author: `user${String(index).padStart(2, '0')}`,
+			date: '2026-03-01T00:00:00.000Z',
+			message: 'm',
+		}));
+		const result = aggregate(many, {from: '2026-03-01', to: '2026-03-01'});
+		expect(result.users.labels).toHaveLength(11);
+		expect(result.users.labels.slice(0, 10)).toStrictEqual(Array.from({length: 10}, (_, index) => `user${String(index).padStart(2, '0')}`));
+		expect(result.users.labels.at(-1)).toBe('(others)');
+		expect(result.users.values.at(-1)).toBe(2);
+	});
+
+	it('returns the 20 most recent commits within the range, newest first', () => {
+		const many: Commit[] = Array.from({length: 25}, (_, index) => ({
+			revision: index + 1,
+			author: 'ada',
+			date: `2026-01-${String(index + 1).padStart(2, '0')}T00:00:00.000Z`,
+			message: `m${index}`,
+		}));
+		many.push({revision: 26, author: 'lin', date: '2025-12-31T00:00:00.000Z', message: 'outside'});
+		const result = aggregate(many, {from: '2026-01-01', to: '2026-01-31'});
+		expect(result.recent).toHaveLength(20);
+		expect(result.recent[0]?.revision).toBe(25);
+		expect(result.recent.at(-1)?.revision).toBe(6);
+		expect(result.recent.some((commit) => commit.revision === 26)).toBe(false);
+	});
+});

package/src/aggregation.ts

@@ -0,0 +1,198 @@
+import {z} from 'zod';
+import {type Commit} from './model.js';
+
+const DAY_MS = 86_400_000;
+const dateTextSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/u, 'Expected YYYY-MM-DD');
+
+export const DEFAULT_CONTRIBUTORS = 10;
+export const DEFAULT_RECENT = 20;
+export const OTHER_CONTRIBUTORS_LABEL = '(others)';
+
+export type DateRange = {readonly from: string; readonly to: string};
+export type Series = {readonly labels: string[]; readonly values: number[]};
+export type StackedDataset = {readonly label: string; readonly values: number[]};
+export type StackedSeries = {readonly labels: string[]; readonly datasets: StackedDataset[]};
+export type ReportData = {
+	readonly range: DateRange;
+	readonly total: number;
+	readonly users: Series;
+	readonly weekdays: Series;
+	readonly hours: Series;
+	readonly days: Series;
+	readonly daysByUser: StackedSeries;
+	readonly months: Series;
+	readonly recent: Commit[];
+};
+
+function parseDateText(value: string): Date {
+	dateTextSchema.parse(value);
+	const date = new Date(`${value}T00:00:00.000Z`);
+	if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) {
+		throw new Error(`Invalid UTC date: ${value}`);
+	}
+	return date;
+}
+
+function dateText(date: Date): string {
+	return date.toISOString().slice(0, 10);
+}
+
+function addDays(value: string, amount: number): string {
+	const date = parseDateText(value);
+	return dateText(new Date(date.getTime() + amount * DAY_MS));
+}
+
+function datasetBounds(commits: readonly Commit[], today: string): DateRange {
+	if (commits.length === 0) {
+		return {from: today, to: today};
+	}
+	const dates = commits.map((commit) => commit.date.slice(0, 10)).sort();
+	const [first] = dates;
+	const last = dates.at(-1);
+	if (first === undefined || last === undefined) {
+		return {from: today, to: today};
+	}
+	return {from: first, to: last};
+}
+
+export function resolveRange(
+	commits: readonly Commit[],
+	options: {readonly from?: string | undefined; readonly to?: string | undefined; readonly relativeDays?: number | undefined},
+	now = new Date(),
+): DateRange {
+	const today = dateText(now);
+	parseDateText(today);
+	if (options.relativeDays !== undefined) {
+		if (options.from !== undefined || options.to !== undefined) {
+			throw new Error('--from/--to cannot be used with --relative-days');
+		}
+		if (!Number.isInteger(options.relativeDays) || options.relativeDays <= 0) {
+			throw new Error('--relative-days must be a positive integer');
+		}
+		return {from: addDays(today, 1 - options.relativeDays), to: today};
+	}
+	const bounds = datasetBounds(commits, today);
+	const from = options.from ?? bounds.from;
+	const to = options.to ?? bounds.to;
+	parseDateText(from);
+	parseDateText(to);
+	if (from > to) {
+		throw new Error(`Report start date ${from} is after end date ${to}`);
+	}
+	return {from, to};
+}
+
+function countSeries(labels: readonly string[], keys: readonly string[]): Series {
+	const counts = new Map(labels.map((label) => [label, 0]));
+	for (const key of keys) {
+		if (counts.has(key)) {
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+	}
+	return {labels: [...labels], values: labels.map((label) => counts.get(label) ?? 0)};
+}
+
+function countStackedSeries(
+	labels: readonly string[],
+	buckets: readonly string[],
+	entries: readonly {readonly key: string; readonly bucket: string}[],
+): StackedSeries {
+	const bucketValues = new Map(buckets.map((bucket) => [bucket, Array.from({length: labels.length}, () => 0)]));
+	const indexByLabel = new Map(labels.map((label, index) => [label, index]));
+	for (const {key, bucket} of entries) {
+		const values = bucketValues.get(bucket);
+		const index = indexByLabel.get(key);
+		if (values === undefined || index === undefined) {
+			continue;
+		}
+		values[index] = (values[index] ?? 0) + 1;
+	}
+	return {labels: [...labels], datasets: buckets.map((bucket) => ({label: bucket, values: [...(bucketValues.get(bucket) ?? [])]}))};
+}
+
+function monthLabels(end: string): string[] {
+	const endDate = parseDateText(end);
+	const result: string[] = [];
+	for (let offset = 11; offset >= 0; offset--) {
+		result.push(dateText(new Date(Date.UTC(endDate.getUTCFullYear(), endDate.getUTCMonth() - offset, 1))).slice(0, 7));
+	}
+	return result;
+}
+
+export function aggregate(commits: readonly Commit[], range: DateRange): ReportData {
+	parseDateText(range.from);
+	parseDateText(range.to);
+	if (range.from > range.to) {
+		throw new Error('Report date range is reversed');
+	}
+	const selected = commits.filter((commit) => {
+		const date = commit.date.slice(0, 10);
+		return date >= range.from && date <= range.to;
+	});
+
+	const userCounts = new Map<string, number>();
+	for (const commit of selected) {
+		const author = commit.author === null || commit.author === '' ? '(no author)' : commit.author;
+		userCounts.set(author, (userCounts.get(author) ?? 0) + 1);
+	}
+	const ranked = [...userCounts.entries()].sort(
+		([leftName, leftCount], [rightName, rightCount]) => rightCount - leftCount || leftName.localeCompare(rightName),
+	);
+	let userLabels: string[];
+	let userValues: number[];
+	const bucketOf = new Map<string, string>();
+	if (ranked.length > DEFAULT_CONTRIBUTORS) {
+		const top = ranked.slice(0, DEFAULT_CONTRIBUTORS);
+		const others = ranked.slice(DEFAULT_CONTRIBUTORS).reduce((sum, [, count]) => sum + count, 0);
+		userLabels = [...top.map(([name]) => name), OTHER_CONTRIBUTORS_LABEL];
+		userValues = [...top.map(([, count]) => count), others];
+		for (const [name] of top) {
+			bucketOf.set(name, name);
+		}
+		for (const [name] of ranked.slice(DEFAULT_CONTRIBUTORS)) {
+			bucketOf.set(name, OTHER_CONTRIBUTORS_LABEL);
+		}
+	} else {
+		userLabels = ranked.map(([name]) => name);
+		userValues = ranked.map(([, count]) => count);
+		for (const [name] of ranked) {
+			bucketOf.set(name, name);
+		}
+	}
+	const weekdayLabels = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+	const hourLabels = Array.from({length: 24}, (_, hour) => hour.toString().padStart(2, '0'));
+	const dayLabels = Array.from({length: 30}, (_, index) => addDays(range.to, index - 29));
+	const months = monthLabels(range.to);
+	const recent = [...selected].sort((left, right) => right.revision - left.revision).slice(0, DEFAULT_RECENT);
+	const daysByUser = countStackedSeries(
+		dayLabels,
+		userLabels,
+		selected.map((commit) => {
+			const author = commit.author === null || commit.author === '' ? '(no author)' : commit.author;
+			return {key: commit.date.slice(0, 10), bucket: bucketOf.get(author) ?? OTHER_CONTRIBUTORS_LABEL};
+		}),
+	);
+	return {
+		range,
+		total: selected.length,
+		users: {labels: userLabels, values: userValues},
+		weekdays: countSeries(
+			weekdayLabels,
+			selected.map((commit) => weekdayLabels[(new Date(commit.date).getUTCDay() + 6) % 7] ?? 'Monday'),
+		),
+		hours: countSeries(
+			hourLabels,
+			selected.map((commit) => new Date(commit.date).getUTCHours().toString().padStart(2, '0')),
+		),
+		days: countSeries(
+			dayLabels,
+			selected.map((commit) => commit.date.slice(0, 10)),
+		),
+		daysByUser,
+		months: countSeries(
+			months,
+			selected.map((commit) => commit.date.slice(0, 7)),
+		),
+		recent,
+	};
+}

package/src/cli.test.ts

@@ -0,0 +1,10 @@
+import {readFileSync} from 'node:fs';
+import {describe, expect, it} from 'vitest';
+import {createProgram} from './cli.js';
+
+describe('CLI', () => {
+	it('reports the package version', () => {
+		const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as {version: string};
+		expect(createProgram().version()).toBe(packageJson.version);
+	});
+});

package/src/cli.ts

@@ -0,0 +1,61 @@
+import {Command, Option} from 'commander';
+import {gather, type GatherOptions} from './gather.js';
+import {generate, type GenerateOptions} from './report.js';
+
+declare const APP_VERSION: string;
+
+type CommonGatherOptions = Omit<GatherOptions, 'url'> & {readonly url: string};
+
+function positiveInteger(value: string): number {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed <= 0) {
+		throw new Error('Expected a positive integer');
+	}
+	return parsed;
+}
+
+function gatherOptions(command: Command): Command {
+	return command
+		.requiredOption('--url <url>', 'SVN repository URL')
+		.option('--username <username>', 'SVN username')
+		.option('--password-env <name>', 'environment variable containing the SVN password', 'SVN_PASSWORD')
+		.option('--data-file <path>', 'JSON state file', 'svn-data.json')
+		.option('--svn-binary <path>', 'SVN executable', 'svn');
+}
+
+function generateOptions(command: Command, includeDataFile = true): Command {
+	if (includeDataFile) {
+		command.option('--data-file <path>', 'JSON state file', 'svn-data.json');
+	}
+	return command
+		.option('--output-dir <path>', 'report output directory', 'output')
+		.option('--from <date>', 'first UTC date (YYYY-MM-DD)')
+		.option('--to <date>', 'last UTC date (YYYY-MM-DD)')
+		.addOption(new Option('--relative-days <days>', 'rolling number of UTC days').argParser(positiveInteger))
+		.option('--title <title>', 'report title', 'Subversion activity');
+}
+
+export function createProgram(): Command {
+	const program = new Command().name('svn-visualizer').description('Generate standalone HTML activity reports from Subversion history').version(APP_VERSION);
+
+	gatherOptions(program.command('gather').description('Incrementally gather SVN history')).action(async (options: CommonGatherOptions) => {
+		const result = await gather(options);
+		console.log(result.added === 0 ? 'No new commits.' : `Gathered ${String(result.added)} new commit(s).`);
+	});
+
+	generateOptions(program.command('generate').description('Generate a standalone HTML report')).action(async (options: GenerateOptions) => {
+		const output = await generate(options);
+		console.log(`Generated ${output}`);
+	});
+
+	generateOptions(gatherOptions(program.command('report').description('Gather history and generate a report')), false).action(
+		async (options: CommonGatherOptions & GenerateOptions) => {
+			const result = await gather(options);
+			console.log(result.added === 0 ? 'No new commits.' : `Gathered ${String(result.added)} new commit(s).`);
+			const output = await generate(options);
+			console.log(`Generated ${output}`);
+		},
+	);
+
+	return program;
+}

package/src/client/main.ts

@@ -0,0 +1,117 @@
+import Chart from 'chart.js/auto';
+
+type Series = {readonly labels: string[]; readonly values: number[]};
+type StackedSeries = {readonly labels: string[]; readonly datasets: readonly {readonly label: string; readonly values: number[]}[]};
+type RecentCommit = {readonly revision: number; readonly author: string | null; readonly date: string; readonly message: string};
+type BrowserData = {
+	readonly days: Series;
+	readonly daysByUser: StackedSeries;
+	readonly months: Series;
+	readonly users: Series;
+	readonly weekdays: Series;
+	readonly hours: Series;
+	readonly recent: RecentCommit[];
+};
+
+const element = document.querySelector('#report-data');
+const reportText = element?.textContent;
+if (reportText === undefined) {
+	throw new Error('Report data is missing');
+}
+const data = JSON.parse(reportText) as BrowserData;
+const charts: Chart[] = [];
+const accent = '#f3b33d';
+const cool = '#6dc8bf';
+const common = {
+	responsive: true,
+	maintainAspectRatio: false,
+	plugins: {legend: {display: false}},
+	scales: {
+		x: {ticks: {color: '#aaa69d'}, grid: {color: '#34413e'}},
+		y: {beginAtZero: true, ticks: {color: '#aaa69d', precision: 0}, grid: {color: '#34413e'}},
+	},
+} as const;
+
+function chart(id: string, series: Series, type: 'bar' | 'line', color: string): void {
+	const canvas = document.querySelector<HTMLCanvasElement>(`#${id}`);
+	if (canvas === null) {
+		return;
+	}
+	charts.push(
+		new Chart(canvas, {
+			type,
+			data: {
+				labels: series.labels,
+				datasets: [{data: series.values, borderColor: color, backgroundColor: `${color}99`, fill: type === 'line', tension: 0.25}],
+			},
+			options: common,
+		}),
+	);
+}
+
+const palette = [accent, cool, '#f77f00', '#90be6d', '#9b5de5', '#f94144', '#577590', '#43aa8b', '#f9844a', '#277da1'];
+
+function stackedChart(id: string, series: StackedSeries): void {
+	const canvas = document.querySelector<HTMLCanvasElement>(`#${id}`);
+	if (canvas === null) {
+		return;
+	}
+	charts.push(
+		new Chart(canvas, {
+			type: 'bar',
+			data: {
+				labels: series.labels,
+				datasets: series.datasets.map((dataset, index) => ({
+					label: dataset.label,
+					data: dataset.values,
+					backgroundColor: `${palette[index % palette.length] ?? accent}99`,
+					borderColor: palette[index % palette.length] ?? accent,
+				})),
+			},
+			options: {
+				...common,
+				plugins: {legend: {display: true, position: 'bottom', labels: {color: '#aaa69d'}}},
+				scales: {
+					x: {...common.scales.x, stacked: true},
+					y: {...common.scales.y, stacked: true},
+				},
+			},
+		}),
+	);
+}
+
+chart('days', data.days, 'line', accent);
+stackedChart('days-by-user', data.daysByUser);
+chart('months', data.months, 'bar', cool);
+chart('users', data.users, 'bar', accent);
+chart('weekdays', data.weekdays, 'bar', cool);
+chart('hours', data.hours, 'bar', accent);
+
+function formatUtc(value: string): string {
+	return new Date(value).toISOString().slice(0, 16).replace('T', ' ');
+}
+
+function renderCommits(commits: readonly RecentCommit[]): void {
+	const tbody = document.querySelector<HTMLTableSectionElement>('#commits');
+	if (tbody === null) {
+		return;
+	}
+	for (const commit of commits) {
+		const row = document.createElement('tr');
+		const revision = document.createElement('td');
+		revision.textContent = String(commit.revision);
+		revision.className = 'rev';
+		const author = document.createElement('td');
+		author.textContent = commit.author ?? '(no author)';
+		const date = document.createElement('td');
+		date.textContent = formatUtc(commit.date);
+		date.className = 'date';
+		const message = document.createElement('td');
+		message.textContent = commit.message;
+		message.className = 'msg';
+		row.append(revision, author, date, message);
+		tbody.append(row);
+	}
+}
+
+renderCommits(data.recent);