git-truck 0.0.0-de7c4e6 → 0.0.0-e01892a

package/build/server/assets/util.server-DIX86N1-.js

@@ -0,0 +1,1822 @@
+import c from "ansi-colors";
+import { createSpinner } from "nanospinner";
+import { exec, spawn } from "node:child_process";
+import { readdir } from "node:fs/promises";
+import path, { join, resolve } from "node:path";
+import { performance } from "node:perf_hooks";
+import { existsSync, promises } from "node:fs";
+import { DuckDBInstance } from "@duckdb/node-api";
+import os from "os";
+import { dirname, resolve as resolve$1 } from "path";
+import { existsSync as existsSync$1, promises as promises$1 } from "fs";
+import { clean, compare, valid } from "semver";
+import colorConvert from "color-convert";
+import "@duckdb/node-api/lib/DuckDBResultReader.js";
+import os$1, { cpus, freemem, totalmem } from "node:os";
+import yargsParser from "yargs-parser";
+const LOG_LEVEL = {
+	SILENT: 0,
+	ERROR: 1,
+	WARN: 2,
+	INFO: 3,
+	DEBUG: 4
+};
+const LOG_LEVEL_LABEL = {
+	SILENT: "",
+	ERROR: "ERR",
+	WARN: "WRN",
+	INFO: "NFO",
+	DEBUG: "DBG"
+};
+const { ERROR, WARN, INFO, DEBUG } = LOG_LEVEL_LABEL;
+const stringToLevelMap = {
+	SILENT: LOG_LEVEL.SILENT,
+	ERROR: LOG_LEVEL.ERROR,
+	WARN: LOG_LEVEL.WARN,
+	INFO: LOG_LEVEL.INFO,
+	DEBUG: LOG_LEVEL.DEBUG
+};
+function setIntialLogLevel() {
+	if (typeof process.env.LOG_LEVEL === "string") {
+		setTimeout(() => {
+			log.debug(`Setting log level to ${process.env.LOG_LEVEL} from environment variable`);
+		});
+		return stringToLevelMap[process.env.LOG_LEVEL.toUpperCase()];
+	}
+	if (typeof process.env.LOG_LEVEL === "number") {
+		setTimeout(() => {
+			log.debug(`Setting log level to ${process.env.LOG_LEVEL} from environment variable`);
+		});
+		return process.env.LOG_LEVEL;
+	}
+	return null;
+}
+let logLevel = setIntialLogLevel();
+const getLogLevel = () => logLevel;
+function error(...messages) {
+	if (logLevel === null) return;
+	if (logLevel >= LOG_LEVEL.ERROR) {
+		process.stderr.write(prefix(ERROR));
+		console.error(...messages);
+	}
+}
+function warn(...messages) {
+	if (logLevel === null) return;
+	if (logLevel >= LOG_LEVEL.WARN) {
+		process.stderr.write(prefix(WARN));
+		console.warn(...messages);
+	}
+}
+function info(...messages) {
+	if (logLevel === null) return;
+	if (logLevel >= LOG_LEVEL.INFO) {
+		process.stderr.write(prefix(INFO));
+		console.info(...messages);
+	}
+}
+function time(label) {
+	if (logLevel === null) return;
+	if (logLevel >= LOG_LEVEL.INFO) console.time(label);
+}
+function timeEnd(label) {
+	if (logLevel === null) return;
+	if (logLevel >= LOG_LEVEL.INFO) {
+		process.stderr.write(prefix(INFO));
+		console.timeEnd(label);
+	}
+}
+function debug(...messages) {
+	if (logLevel === null) return;
+	if (logLevel >= LOG_LEVEL.DEBUG) {
+		process.stderr.write(prefix(DEBUG));
+		console.debug(...messages);
+	}
+}
+function prefix(label) {
+	const formatPrefix = (label$1, colorFn = (s) => s) => `${colorFn(` ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} ${label$1} `)} `;
+	if (process.env.COLOR === "0") return `[${label}] `;
+	switch (label) {
+		case LOG_LEVEL_LABEL.ERROR: return formatPrefix(LOG_LEVEL_LABEL.ERROR, c.bgRedBright.black.bold);
+		case LOG_LEVEL_LABEL.WARN: return formatPrefix(LOG_LEVEL_LABEL.WARN, c.bgYellow.black.bold);
+		case LOG_LEVEL_LABEL.INFO: return formatPrefix(LOG_LEVEL_LABEL.INFO, c.bgBlueBright.black.bold);
+		case LOG_LEVEL_LABEL.DEBUG: return formatPrefix(LOG_LEVEL_LABEL.DEBUG, c.bgWhite.bold);
+		default: throw Error("Invalid log level");
+	}
+}
+const log = {
+	error,
+	warn,
+	info,
+	debug,
+	time,
+	timeEnd
+};
+function dateFormatLong(epochTime) {
+	if (!epochTime) return "Invalid date";
+	return (/* @__PURE__ */ new Date(epochTime * 1e3)).toLocaleString("en-gb", {
+		day: "2-digit",
+		month: "short",
+		year: "numeric"
+	});
+}
+function dateFormatCalendarHeader(epochTime) {
+	if (!epochTime) return "Invalid date";
+	return new Date(epochTime).toLocaleString("en-gb", {
+		month: "long",
+		year: "numeric"
+	});
+}
+function dateFormatShort(epochTime) {
+	return new Date(epochTime).toLocaleString("en-gb", {
+		day: "2-digit",
+		month: "short",
+		year: "2-digit"
+	});
+}
+function dateTimeFormatShort(epochTime) {
+	return new Date(epochTime).toLocaleString("da-dk", {
+		hour: "2-digit",
+		minute: "2-digit",
+		day: "2-digit",
+		month: "short",
+		year: "2-digit"
+	});
+}
+function dateFormatRelative(epochTime) {
+	const now = Date.now();
+	const hourMillis = 60 * 60 * 1e3;
+	const dayMillis = 24 * hourMillis;
+	const difference = now - epochTime * 1e3;
+	if (difference < 0) return "Unknown time ago";
+	if (difference > dayMillis) {
+		const days = Math.floor(difference / dayMillis);
+		return `${days} day${days > 1 ? "s" : ""} ago`;
+	}
+	const hours = Math.floor(difference / hourMillis);
+	if (hours > 1) return `${hours} hours ago`;
+	if (hours === 1) return "1 hour ago";
+	return "<1 hour ago";
+}
+const last = (arr) => arr.at(-1);
+const allExceptLast = (arr) => {
+	if (arr.length <= 1) return [];
+	return arr.slice(0, arr.length - 1);
+};
+const allExceptFirst = (arr) => {
+	if (arr.length <= 1) return [];
+	return arr.slice(1);
+};
+function getSeparator(path$1) {
+	if (path$1.includes("\\")) return "\\";
+	return "/";
+}
+const getPathFromRepoAndHead = (repo, branch) => [repo, encodeURIComponent(branch)].join("/");
+const branchCompare = (a, b) => {
+	const defaultBranchNames = ["main", "master"];
+	if (defaultBranchNames.includes(a)) return -1;
+	if (defaultBranchNames.includes(b)) return 1;
+	return a.toLowerCase().localeCompare(b.toLowerCase());
+};
+const semverCompare = (a, b) => {
+	const validA = valid(clean(a));
+	const validB = valid(clean(b));
+	if (!validA || !validB) {
+		if (validA) return 1;
+		if (validB) return -1;
+		return a.toLowerCase().localeCompare(b.toLowerCase());
+	}
+	return compare(validA, validB);
+};
+const brightnessCalculationCache = /* @__PURE__ */ new Map();
+function weightedDistanceIn3D(hex) {
+	const rgb = hexToRgb(hex);
+	return Math.sqrt(Math.pow(rgb[0], 2) * .241 + Math.pow(rgb[1], 2) * .691 + Math.pow(rgb[2], 2) * .068);
+}
+const hexToRgbCache = /* @__PURE__ */ new Map();
+function hexToRgb(hexString) {
+	const cachedColor = hexToRgbCache.get(hexString);
+	if (cachedColor) return cachedColor;
+	const rgb = colorConvert.hex.rgb(hexString);
+	hexToRgbCache.set(hexString, rgb);
+	return rgb;
+}
+const isDarkColor = (color) => {
+	if (!/^#([0-9A-F]{3}){1,2}$/i.test(color)) throw new Error(`Invalid hex color: ${color}`);
+	const cachedColor = brightnessCalculationCache.get(color);
+	if (cachedColor !== void 0) return cachedColor;
+	const brightness = weightedDistanceIn3D(color);
+	const isDark = brightness < 186;
+	brightnessCalculationCache.set(color, isDark);
+	return isDark;
+};
+const colorCache = /* @__PURE__ */ new Map();
+function hslToHex(h, s, l) {
+	const key = `${h}-${s}-${l}`;
+	const cachedColor = colorCache.get(key);
+	if (cachedColor) return cachedColor;
+	const hex = `#${colorConvert.hsl.hex([
+		h,
+		s,
+		l
+	])}`;
+	colorCache.set(key, hex);
+	return hex;
+}
+function getLightness(hex) {
+	return weightedDistanceIn3D(hex) / 255;
+}
+const isTree = (d = null) => d?.type === "tree";
+const isBlob = (d = null) => d?.type === "blob";
+function generateVersionComparisonLink({ currentVersion, latestVersion: latestVersion$1 }) {
+	return `https://github.com/git-truck/git-truck/compare/v${currentVersion}...v${latestVersion$1}`;
+}
+function invariant(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function sleep(ms) {
+	return new Promise((resolve$2) => {
+		setTimeout(resolve$2, ms);
+	});
+}
+function getWeek(date) {
+	const tempDate = new Date(date);
+	tempDate.setHours(0, 0, 0, 0);
+	tempDate.setDate(tempDate.getDate() + 4 - (tempDate.getDay() || 7));
+	const yearStart = new Date(tempDate.getFullYear(), 0, 1);
+	const weekNo = Math.ceil(((tempDate.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+	return weekNo;
+}
+function getTimeIntervals(timeUnit, minTime, maxTime) {
+	const intervals = [];
+	const startDate = /* @__PURE__ */ new Date(minTime * 1e3);
+	const endDate = /* @__PURE__ */ new Date(maxTime * 1e3);
+	const currentDate = new Date(startDate);
+	while (currentDate <= endDate) {
+		const currTime = currentDate.getTime() / 1e3;
+		if (timeUnit === "week") {
+			const weekNum = getWeek(currentDate);
+			intervals.push([`Week ${weekNum < 10 ? "0" : ""}${weekNum} ${currentDate.getFullYear()}`, currTime]);
+			currentDate.setDate(currentDate.getDate() + 7);
+		} else if (timeUnit === "year") {
+			intervals.push([currentDate.getFullYear().toString(), currTime]);
+			currentDate.setFullYear(currentDate.getFullYear() + 1);
+		} else if (timeUnit === "month") {
+			intervals.push([currentDate.toLocaleString("en-gb", {
+				month: "long",
+				year: "numeric"
+			}), currTime]);
+			currentDate.setMonth(currentDate.getMonth() + 1);
+		} else if (timeUnit === "day") {
+			intervals.push([currentDate.toLocaleDateString("en-gb", {
+				day: "numeric",
+				month: "long",
+				year: "numeric",
+				weekday: "short"
+			}).replace(",", ""), currTime]);
+			currentDate.setDate(currentDate.getDate() + 1);
+		}
+	}
+	return intervals;
+}
+function analyzeRenamedFile(file, timestamp, authortime, renamedFiles, repo) {
+	const movedFileRegex = /(?:.*{(?<oldPath>.*)\s=>\s(?<newPath>.*)}.*)|(?:^(?<oldPath2>.*) => (?<newPath2>.*))$/gm;
+	const replaceRegex = /{.*}/gm;
+	const match = movedFileRegex.exec(file);
+	const groups = match?.groups ?? {};
+	let oldPath;
+	let newPath;
+	if (groups["oldPath"] || groups["newPath"]) {
+		const oldP = groups["oldPath"] ?? "";
+		const newP = groups["newPath"] ?? "";
+		oldPath = repo + "/" + file.replace(replaceRegex, oldP).replace("//", "/");
+		newPath = repo + "/" + file.replace(replaceRegex, newP).replace("//", "/");
+	} else {
+		oldPath = repo + "/" + (groups["oldPath2"] ?? "");
+		newPath = repo + "/" + (groups["newPath2"] ?? "");
+	}
+	renamedFiles.push({
+		fromname: oldPath,
+		toname: newPath,
+		timestamp,
+		timestampauthor: authortime
+	});
+	return newPath;
+}
+const formatMs = (ms) => {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	else return `${(ms / 1e3).toFixed(2)}s`;
+};
+/**
+* This functions handles try / catch for you, so your code stays flat.
+* @param promise An async function
+* @returns A tuple of the result and an error. If there is no error, the error will be null.
+*/
+async function promiseHelper(promise) {
+	try {
+		return [await promise, null];
+	} catch (e) {
+		return [null, e];
+	}
+}
+const numToFriendlyString = (num) => {
+	if (num >= 1e6) return `${(num / 1e6).toFixed(1)}M`;
+	else if (num >= 1e3) return `${(num / 1e3).toFixed(1)}K`;
+	else return num.toString();
+};
+var DB = class DB {
+	connectionPromise;
+	repoSanitized;
+	branchSanitized;
+	selectedRange;
+	static async init(dbPath) {
+		const dir = dirname(dbPath);
+		if (!existsSync$1(dir)) await promises$1.mkdir(dir, { recursive: true });
+		const instance = await DuckDBInstance.create(dbPath, { temp_directory: dir });
+		const connection = await instance.connect();
+		await this.initTables(connection);
+		await this.initViews(connection, 0, 1e12);
+		return connection;
+	}
+	static async clearCache() {
+		const dir = resolve$1(os.tmpdir(), "git-truck-cache");
+		if (!existsSync$1(dir)) return;
+		await promises$1.rm(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+	constructor(repo, branch) {
+		this.repoSanitized = repo.replace(/\W/g, "_") + "_";
+		this.branchSanitized = branch.replace(/\W/g, "_") + "_";
+		const dbPath = resolve$1(os.tmpdir(), "git-truck-cache", this.repoSanitized, this.branchSanitized + ".db");
+		this.connectionPromise = DB.init(dbPath);
+		this.selectedRange = [0, 1e12];
+	}
+	async disconnect() {
+		const connection = await this.connectionPromise;
+		connection.disconnectSync();
+	}
+	async query(query) {
+		return (await (await this.connectionPromise).runAndReadAll(query)).getRowObjects();
+	}
+	async run(query) {
+		await (await this.connectionPromise).run(query);
+	}
+	/**
+	
+	* usingTableAppender is a helper function to create an appender and close it after the callback is done.
+	
+	* It is useful for inserting large amounts of data into the database efficiently.
+	
+	* @param table The table to append to
+	
+	* @param callback The callback that will be called with an appender
+	
+	* @returns The result of the callback
+	
+	*/
+	async usingTableAppender(table, callback) {
+		const appender = await (await this.connectionPromise).createAppender(table);
+		try {
+			await callback(appender);
+		} finally {
+			appender.closeSync();
+		}
+	}
+	async checkpoint() {
+		await this.run("CHECKPOINT;");
+	}
+	static async initTables(db) {
+		await db.run(`
+      CREATE TABLE IF NOT EXISTS commits (
+        hash VARCHAR,
+        author VARCHAR,
+        committertime UINTEGER,
+        authortime UINTEGER
+      );
+      CREATE TABLE IF NOT EXISTS filechanges (
+        commithash VARCHAR,
+        insertions UINTEGER,
+        deletions UINTEGER,
+        filepath VARCHAR,
+      );
+      CREATE TABLE IF NOT EXISTS authorunions (
+        alias VARCHAR PRIMARY KEY,
+        actualname VARCHAR
+      );
+      CREATE TABLE IF NOT EXISTS renames (
+        fromname VARCHAR,
+        toname VARCHAR,
+        timestamp UINTEGER,
+        timestampauthor UINTEGER
+      );
+      CREATE TABLE IF NOT EXISTS hiddenfiles (
+        path VARCHAR
+      );
+      CREATE TABLE IF NOT EXISTS metadata (
+        field VARCHAR,
+        value UBIGINT,
+        value2 VARCHAR
+      );
+      CREATE TABLE IF NOT EXISTS temporary_renames (
+        fromname VARCHAR,
+        toname VARCHAR,
+        timestamp UINTEGER,
+        timestampend UINTEGER
+      );
+      CREATE TABLE IF NOT EXISTS files (
+        path VARCHAR
+      );
+    `);
+	}
+	async clearAllTables() {
+		await this.run(`
+      DELETE FROM commits;
+      DELETE FROM filechanges;
+      DELETE FROM authorunions;
+      DELETE FROM renames;
+      DELETE FROM hiddenfiles;
+      DELETE FROM metadata;
+      DELETE FROM temporary_renames;
+      DELETE FROM files;
+    `);
+	}
+	async createIndexes() {
+		await this.run(`
+      CREATE INDEX IF NOT EXISTS commitstime ON commits(committertime);
+      CREATE INDEX IF NOT EXISTS renamestime ON renames(timestamp);
+    `);
+	}
+	static async initViews(db, start, end) {
+		await db.run(`
+      CREATE OR REPLACE VIEW commits_unioned AS
+      SELECT c.hash, CASE WHEN u.actualname IS NOT NULL THEN u.actualname ELSE c.author END AS author, c.committertime, c.authortime FROM
+      commits c LEFT JOIN authorunions u ON c.author = u.alias
+      WHERE c.committertime BETWEEN ${start} AND ${end};
+
+      CREATE OR REPLACE VIEW filechanges_commits AS
+      SELECT f.commithash, f.insertions, f.deletions, f.filepath, author, c.committertime, c.authortime FROM
+      filechanges f JOIN commits_unioned c on f.commithash = c.hash;
+
+      CREATE OR REPLACE VIEW filechanges_commits_renamed AS
+      SELECT f.commithash, f.insertions, f.deletions, f.author, f.committertime, f.authortime,
+          CASE
+              WHEN r.toname IS NOT NULL THEN r.toname
+              ELSE f.filepath
+          END AS filepath
+      FROM filechanges_commits f
+      LEFT JOIN temporary_renames r ON f.filepath = r.fromname
+      AND (
+        f.committertime BETWEEN r.timestamp AND r.timestampend
+        --OR (f.committertime = r.timestampend + 1
+        --AND f.authortime < r.timestampend)
+      );
+
+      CREATE OR REPLACE VIEW filtered_files AS
+      SELECT f.path
+      FROM files f
+      LEFT JOIN hiddenfiles g ON
+          (g.path LIKE '*.%' AND f.path GLOB g.path)
+          OR (g.path NOT LIKE '*.%' AND f.path GLOB g.path || '*')
+      WHERE g.path IS NULL;
+
+
+      CREATE OR REPLACE VIEW filechanges_commits_renamed_files AS
+      SELECT * FROM filechanges_commits_renamed f
+      INNER JOIN filtered_files fi on fi.path = f.filepath;
+
+      CREATE OR REPLACE VIEW relevant_renames AS
+      SELECT fromname, toname, min(timestamp) AS timestamp, timestampauthor FROM renames
+      WHERE timestamp BETWEEN ${start} AND ${end}
+      group by fromname, toname, timestampauthor;
+
+      CREATE OR REPLACE VIEW combined_result AS
+      SELECT f.commithash, f.insertions, f.deletions, c.committertime, c.authortime,
+        CASE WHEN u.actualname IS NOT NULL THEN u.actualname ELSE c.author END AS author,
+        CASE
+            WHEN r.toname IS NOT NULL THEN r.toname
+            ELSE f.filepath
+        END AS filepath
+      FROM commits c
+      LEFT JOIN authorunions u ON c.author = u.alias
+      JOIN filechanges f ON f.commithash = c.hash
+      LEFT JOIN temporary_renames r ON f.filepath = r.fromname AND c.committertime BETWEEN r.timestamp AND r.timestampend
+      INNER JOIN files fi on fi.path = filepath
+      WHERE c.committertime BETWEEN ${start} AND ${end}
+
+    `);
+	}
+	async updateTimeInterval(timeSeriesStart, timeSeriesEnd) {
+		const start = Number.isNaN(timeSeriesStart) ? 0 : timeSeriesStart;
+		const end = Number.isNaN(timeSeriesEnd) ? 1e12 : timeSeriesEnd;
+		this.selectedRange = [start, end];
+		await DB.initViews(await this.connectionPromise, start, end);
+	}
+	async replaceAuthorUnions(unions) {
+		await this.run(`
+      DELETE FROM authorunions;
+    `);
+		await this.usingTableAppender("authorunions", async (appender) => {
+			for (const union of unions) {
+				const [actualname, ...aliases] = union;
+				for (const alias of aliases) {
+					appender.appendVarchar(alias);
+					appender.appendVarchar(actualname);
+					appender.endRow();
+				}
+			}
+		});
+	}
+	async replaceTemporaryRenames(renames) {
+		await this.run(`
+      DELETE FROM temporary_renames;
+    `);
+		await this.usingTableAppender("temporary_renames", async (appender) => {
+			for (const rename of renames) {
+				rename.fromname ? appender.appendVarchar(rename.fromname) : appender.appendDefault();
+				rename.toname ? appender.appendVarchar(rename.toname) : appender.appendDefault();
+				appender.appendUInteger(rename.timestamp);
+				appender.appendUInteger(rename.timestampend);
+				appender.endRow();
+			}
+		});
+	}
+	async getAuthorUnions() {
+		const res = (await (await this.connectionPromise).runAndReadAll(`
+      SELECT actualname, LIST(alias) as aliases FROM authorunions GROUP BY actualname;
+    `)).getRowObjects();
+		return res.map((row) => [row["actualname"], ...row["aliases"].items]);
+	}
+	async getRawUnions() {
+		const res = await this.query(`
+      SELECT * FROM authorunions;
+    `);
+		return res;
+	}
+	async getCommitTimeAtIndex(idx) {
+		const res = await this.query(`
+      SELECT committertime FROM commits ORDER BY committertime DESC OFFSET ${idx} LIMIT 1;
+    `);
+		return res.length > 0 ? Number(res[0]["committertime"]) : 0;
+	}
+	async getOverallTimeRange() {
+		const res = await this.query(`
+      SELECT MIN(committertime) as min, MAX(committertime) as max from commits;
+    `);
+		return [Number(res[0]["min"]), Number(res[0]["max"])];
+	}
+	async getCurrentRenameIntervals() {
+		const res = await this.query(`
+        SELECT * FROM relevant_renames ORDER BY timestamp DESC, timestampauthor DESC;
+    `);
+		return res.map((row) => {
+			return {
+				fromname: row["fromname"],
+				toname: row["toname"],
+				timestamp: 0,
+				timestampend: Number(row["timestamp"])
+			};
+		});
+	}
+	async getHiddenFiles() {
+		const res = await this.query(`
+      SELECT path FROM hiddenfiles ORDER BY path ASC;
+    `);
+		return res.map((row) => row["path"]);
+	}
+	async replaceHiddenFiles(hiddenFiles) {
+		await this.run(`
+      DELETE FROM hiddenfiles;
+    `);
+		await this.usingTableAppender("hiddenfiles", async (appender) => {
+			for (const path$1 of hiddenFiles) {
+				appender.appendVarchar(path$1);
+				appender.endRow();
+			}
+		});
+	}
+	async getCommits(path$1, count) {
+		const res = await this.query(`
+      SELECT distinct commithash, author, committertime, authortime, message, body
+      FROM filechanges_commits_renamed_cached
+      WHERE filepath GLOB '${path$1}*'
+      ORDER BY committertime DESC, commithash
+      LIMIT ${count};
+    `);
+		return res.map((row) => {
+			return {
+				author: row["author"],
+				committertime: row["committertime"],
+				authortime: row["authortime"],
+				body: row["body"],
+				hash: row["commithash"],
+				message: row["message"]
+			};
+		});
+	}
+	async getCommitHashes(path$1, count) {
+		const res = await this.query(`
+      SELECT distinct commithash
+      FROM filechanges_commits_renamed_cached
+      WHERE filepath GLOB '${path$1}*'
+      ORDER BY committertime DESC, commithash
+      LIMIT ${count};
+    `);
+		return res.map((row) => {
+			return row["commithash"];
+		});
+	}
+	async getCommitCountForPath(path$1) {
+		const res = await this.query(`
+      SELECT COUNT(DISTINCT commithash) AS count from filechanges_commits_renamed_cached WHERE filepath GLOB '${path$1}*';
+    `);
+		return Number(res[0]["count"]);
+	}
+	async getCommitCountPerFile() {
+		const res = await this.query(`
+      SELECT filepath, count(DISTINCT commithash) AS count
+      FROM filechanges_commits_renamed_cached
+      GROUP BY filepath
+      ORDER BY count DESC;
+    `);
+		const result = {};
+		res.forEach((row) => {
+			result[row["filepath"]] = Number(row["count"]);
+		});
+		return result;
+	}
+	async getLastChangedPerFile() {
+		const res = await this.query(`
+      SELECT filepath, MAX(committertime) AS max_time
+      FROM filechanges_commits_renamed_cached
+      GROUP BY filepath;
+    `);
+		const result = {};
+		res.forEach((row) => {
+			result[row["filepath"]] = Number(row["max_time"]);
+		});
+		return result;
+	}
+	async getAuthorCountPerFile() {
+		const res = await this.query(`
+      SELECT filepath, count(DISTINCT author) AS author_count
+      FROM filechanges_commits_renamed_cached
+      GROUP BY filepath;
+    `);
+		const result = {};
+		res.forEach((row) => {
+			result[row["filepath"]] = Number(row["author_count"]);
+		});
+		return result;
+	}
+	async getMaxMinContribCounts() {
+		const res = await this.query(`
+      SELECT MAX(contribsum) as max, MIN(contribsum) as min FROM (SELECT filepath, SUM(insertions + deletions) AS contribsum FROM filechanges_commits_renamed_cached GROUP BY filepath);
+    `);
+		return {
+			max: Number(res[0]["max"]),
+			min: Number(res[0]["min"])
+		};
+	}
+	async getContribSumPerFile() {
+		const res = await this.query(`
+      SELECT filepath, SUM(insertions + deletions) AS contribsum FROM filechanges_commits_renamed_cached GROUP BY filepath;
+    `);
+		return res.reduce((acc, row) => {
+			acc[row["filepath"]] = Number(row["contribsum"]);
+			return acc;
+		}, {});
+	}
+	async getDominantAuthorPerFile() {
+		const res = await this.query(`
+      WITH RankedAuthors AS (
+        SELECT filepath, author, SUM(insertions + deletions) AS total_contribcount,
+        ROW_NUMBER() OVER (PARTITION BY filepath ORDER BY SUM(insertions + deletions) DESC, author ASC) AS rank
+        FROM filechanges_commits_renamed_cached
+        GROUP BY filepath, author
+      )
+      SELECT filepath, author, total_contribcount
+      FROM RankedAuthors
+      WHERE rank = 1;
+    `);
+		const result = {};
+		res.forEach((row) => {
+			const author = row["author"];
+			if (typeof author !== "string") throw new Error("Error when getting dominant author per file: Author is not a string");
+			result[row["filepath"]] = {
+				author,
+				contribcount: Number(row["total_contribcount"])
+			};
+		});
+		return result;
+	}
+	async updateCachedResult() {
+		await this.run(`
+    CREATE OR REPLACE TEMP TABLE filechanges_commits_renamed_cached AS
+    SELECT * FROM filechanges_commits_renamed_files;
+    `);
+	}
+	async addRenames(renames) {
+		await this.usingTableAppender("renames", async (appender) => {
+			for (const rename of renames) {
+				rename.fromname ? appender.appendVarchar(rename.fromname) : appender.appendDefault();
+				rename.toname ? appender.appendVarchar(rename.toname) : appender.appendDefault();
+				appender.appendUInteger(rename.timestamp);
+				appender.appendUInteger(rename.timestampauthor);
+				appender.endRow();
+			}
+		});
+	}
+	async replaceFiles(files) {
+		await this.run(`
+      DELETE FROM files;
+    `);
+		await this.usingTableAppender("files", async (appender) => {
+			for (const file of files) {
+				appender.appendVarchar(file.path);
+				appender.endRow();
+			}
+		});
+	}
+	async getFiles() {
+		const res = await this.query(`
+      FROM files;
+    `);
+		return res.map((row) => row["path"]);
+	}
+	async commitTableEmpty() {
+		const res = await this.query(`
+      SELECT * FROM commits LIMIT 1;
+    `);
+		return res.length === 0;
+	}
+	async getLatestCommitHash(beforeTime) {
+		const res = await this.query(`
+      SELECT hash FROM commits WHERE committertime <= ${beforeTime ?? 1e12} ORDER BY committertime DESC LIMIT 1;
+    `);
+		if (res.length < 1) throw new Error("Could not get latest commit hash. Commits table is empty. beforeTime set to " + beforeTime);
+		return res[0]["hash"];
+	}
+	async getAuthors() {
+		const res = await this.query(`
+      SELECT DISTINCT author FROM commits_unioned;
+    `);
+		return res.map((row) => row["author"]);
+	}
+	async getNewestAndOldestChangeDates() {
+		const res = await this.query(`
+      SELECT MAX(max_time) AS newest, MIN(max_time) AS oldest FROM (SELECT filepath, MAX(committertime) AS max_time FROM filechanges_commits_renamed_cached GROUP BY filepath);
+    `);
+		return {
+			newestChangeDate: res[0]["newest"],
+			oldestChangeDate: res[0]["oldest"]
+		};
+	}
+	async getCommitCount() {
+		const res = await this.query(`
+      SELECT count(distinct commithash) AS count FROM filechanges_commits_renamed_cached;
+    `);
+		return Number(res[0]["count"]);
+	}
+	async getMaxAndMinCommitCount() {
+		const res = await this.query(`
+      SELECT MAX(count) as max_commits, MIN(count) as min_commits FROM (SELECT filepath, count(distinct commithash) AS count FROM filechanges_commits_renamed_cached GROUP BY filepath ORDER BY count DESC);
+    `);
+		return {
+			maxCommitCount: Number(res[0]["max_commits"]),
+			minCommitCount: Number(res[0]["min_commits"])
+		};
+	}
+	async getAuthorContribsForPath(path$1, isblob) {
+		const res = await this.query(`
+      SELECT author, SUM(insertions + deletions) AS contribsum FROM filechanges_commits_renamed_cached WHERE filepath ${isblob ? "=" : "GLOB"} '${path$1}${isblob ? "" : "*"}' GROUP BY author ORDER BY contribsum DESC, author ASC;
+    `);
+		return res.map((row) => {
+			return {
+				author: row["author"],
+				contribs: Number(row["contribsum"])
+			};
+		});
+	}
+	getTimeStringFormat(timerange) {
+		const durationDays = (timerange[1] - timerange[0]) / (60 * 60 * 24);
+		if (durationDays < 150) return ["%a %-d %B %Y", "day"];
+		if (durationDays < 1e3) return ["Week %V %Y", "week"];
+		if (durationDays < 4e3) return ["%B %Y", "month"];
+		return ["%Y", "year"];
+	}
+	async getCommitCountPerTime(timerange) {
+		const [query, timeUnit] = this.getTimeStringFormat(timerange);
+		const res = await this.query(`
+      SELECT strftime(date, '${query}') as timestring, count(*) AS count, MIN(committertime) AS ct FROM (SELECT date_trunc('${timeUnit}',to_timestamp(committertime)) AS date, committertime FROM commits) GROUP BY date ORDER BY date ASC;
+    `);
+		const mapped = res.map((x) => {
+			return {
+				date: x["timestring"],
+				count: Number(x["count"]),
+				timestamp: Number(x["ct"])
+			};
+		});
+		const final = [];
+		const allIntervals = getTimeIntervals(timeUnit, timerange[0], timerange[1]);
+		for (const [dateString, timestamp] of allIntervals) {
+			const existing = mapped.find((x) => x.date === dateString);
+			if (existing) final.push(existing);
+			else final.push({
+				date: dateString,
+				count: 0,
+				timestamp
+			});
+		}
+		const sorted = final.sort((a, b) => a.timestamp - b.timestamp);
+		return sorted;
+	}
+	async updateColorSeed(seed) {
+		await this.run(`
+    DELETE FROM metadata WHERE field = 'colorseed';
+      INSERT INTO metadata (field, value, value2) VALUES ('colorseed', null, '${seed}');
+      `);
+		console.log("inserted seed", seed);
+	}
+	async getColorSeed() {
+		const res = await this.query(`
+      SELECT value2 FROM metadata WHERE field = 'colorseed';
+    `);
+		if (res.length < 1) return null;
+		console.log("retrieved seed", res[0]["value2"]);
+		return res[0]["value2"];
+	}
+	async getLastRunInfo() {
+		const res = await this.query(`
+      SELECT value as time, value2 as hash FROM metadata WHERE field = 'finished' ORDER BY value DESC LIMIT 1;
+    `);
+		if (!res[0]) return {
+			time: 0,
+			hash: ""
+		};
+		return {
+			time: Number(res[0]["time"]),
+			hash: res[0]["hash"]
+		};
+	}
+	async addCommits(commits) {
+		await this.usingTableAppender("commits", async (appender) => {
+			for (const [hash, commit] of commits) {
+				if (!commit) throw new Error(`Commit with hash ${hash} is undefined`);
+				appender.appendVarchar(hash);
+				appender.appendVarchar(commit.author);
+				appender.appendUInteger(commit.committertime);
+				appender.appendUInteger(commit.authortime);
+				appender.endRow();
+			}
+		});
+		await this.usingTableAppender("filechanges", async (appender) => {
+			for (const [hash, commit] of commits) {
+				if (!commit) throw new Error(`Commit with hash ${hash} is undefined`);
+				for (const change of commit.fileChanges) {
+					appender.appendVarchar(commit.hash);
+					appender.appendUInteger(change.insertions);
+					appender.appendUInteger(change.deletions);
+					appender.appendVarchar(change.path);
+					appender.endRow();
+				}
+			}
+		});
+	}
+};
+const AnalyzerDataInterfaceVersion = 16;
+const ANALYZER_CACHE_MISS_REASONS = {
+	OTHER_REPO: "The cache was not created for this repo",
+	NOT_CACHED: "No cache was found",
+	BRANCH_HEAD_CHANGED: "Branch head changed",
+	DATA_VERSION_MISMATCH: "Outdated cache"
+};
+var GitCaller = class GitCaller {
+	useCache = true;
+	catFileCache = /* @__PURE__ */ new Map();
+	constructor(repo, branch, repoPath) {
+		this.repo = repo;
+		this.branch = branch;
+		this.repoPath = repoPath;
+	}
+	static async isGitRepo(path$1) {
+		const gitFolderPath = resolve(path$1, ".git");
+		const hasGitFolder = existsSync(gitFolderPath);
+		if (!hasGitFolder) return false;
+		const [, findBranchHeadError] = await promiseHelper(GitCaller.findBranchHead(path$1));
+		return Boolean(hasGitFolder && !findBranchHeadError);
+	}
+	static async isValidRevision(revision, path$1) {
+		const gitFolder = join(path$1, ".git");
+		const [, findBranchHeadError] = await promiseHelper(GitCaller._revParse(gitFolder, revision));
+		return !findBranchHeadError;
+	}
+	/**
+	
+	*
+	
+	* @param repo The repo to find the branch head for
+	
+	* @param branch The branch to find the head for (default: checkout branch)
+	
+	* @returns Promise<[branchHead: string, branchName: string]>
+	
+	*/
+	static async findBranchHead(repo, branch) {
+		if (!branch) {
+			const [foundBranch, getBranchError] = await promiseHelper(GitCaller._getRepositoryHead(repo));
+			if (getBranchError) throw getBranchError;
+			branch = foundBranch;
+		}
+		const gitFolder = join(repo, ".git");
+		if (!existsSync(gitFolder)) throw Error("No git folder exists at " + gitFolder);
+		const branchHead = await GitCaller._revParse(gitFolder, branch);
+		log.debug(`${branch} -> [commit] ${branchHead}`);
+		return [branchHead, branch];
+	}
+	static getCachePath(repo, branch) {
+		return resolve(os$1.tmpdir(), "git-truck", repo, `${branch}.json`);
+	}
+	async getRepositoryHead() {
+		return await GitCaller._getRepositoryHead(this.repo);
+	}
+	async gitLogSpecificCommits(commits) {
+		const args = [
+			"log",
+			"--no-walk",
+			"--numstat",
+			"--format=\"author <|%aN|> date <|%ct %at|> message <|%s|> body <|%b|> hash <|%H|>\"",
+			...commits
+		];
+		const result = await runProcess(this.repoPath, "git", args);
+		return result.trim();
+	}
+	static async _getRepositoryHead(dir) {
+		const result = await runProcess(dir, "git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]);
+		return result.trim();
+	}
+	async lsTree(hash) {
+		return await GitCaller._lsTree(this.repoPath, hash);
+	}
+	static async _lsTree(repo, hash) {
+		const result = await runProcess(repo, "git", [
+			"ls-tree",
+			"-rlt",
+			hash
+		]);
+		return result.trim();
+	}
+	async revParse(ref) {
+		return await GitCaller._revParse(this.repoPath, ref);
+	}
+	static async _revParse(dir, ref) {
+		const result = await runProcess(dir, "git", [
+			"rev-list",
+			"-n",
+			"1",
+			ref
+		]);
+		return result.trim();
+	}
+	static async getRepoMetadata(repoPath) {
+		const repoDir = getDirName(repoPath);
+		const parentDir = getBaseDirFromPath(repoDir);
+		const isRepo = await GitCaller.isGitRepo(repoPath);
+		if (!isRepo) return {
+			status: "Error",
+			errorMessage: "Not a valid git repository",
+			name: repoDir,
+			path: repoPath,
+			parentDirPath: parentDir
+		};
+		const refs = GitCaller.parseRefs(await GitCaller._getRefs(repoPath));
+		const allHeads = new Set([...Object.entries(refs.Branches), ...Object.entries(refs.Tags)]).values();
+		const headsWithCaches = await Promise.all(Array.from(allHeads).map(async ([headName, head]) => {
+			const [result] = await GitCaller.retrieveCachedResult({
+				repo: getDirName(repoPath),
+				branch: headName,
+				branchHead: head
+			});
+			return {
+				headName,
+				head,
+				isAnalyzed: result !== null
+			};
+		}));
+		const analyzedHeads = headsWithCaches.filter((head) => head.isAnalyzed).reduce((acc, headEntry) => ({
+			...acc,
+			[headEntry.head]: true,
+			[headEntry.headName]: true
+		}), {});
+		const repoHead = await GitCaller._getRepositoryHead(repoPath);
+		try {
+			const [findBranchHeadResult, error$1] = await promiseHelper(GitCaller.findBranchHead(repoPath));
+			if (error$1) return {
+				status: "Error",
+				errorMessage: error$1.message,
+				name: repoDir,
+				path: repoPath,
+				parentDirPath: parentDir
+			};
+			const [branchHead, branch] = findBranchHeadResult;
+			const [data, reasons] = await GitCaller.retrieveCachedResult({
+				repo: repoDir,
+				branch,
+				branchHead
+			});
+			if (!data) return {
+				status: "Success",
+				isAnalyzed: false,
+				data: null,
+				reasons,
+				name: repoDir,
+				path: repoPath,
+				parentDirPath: parentDir,
+				currentHead: branch,
+				refs,
+				analyzedHeads
+			};
+			return {
+				status: "Success",
+				isAnalyzed: true,
+				data,
+				reasons: [],
+				name: repoDir,
+				path: repoPath,
+				parentDirPath: parentDir,
+				currentHead: repoHead,
+				refs,
+				analyzedHeads
+			};
+		} catch (e) {
+			return {
+				status: "Error",
+				errorMessage: e instanceof Error ? e.message : "Unknown error",
+				name: repoDir,
+				path: repoPath,
+				parentDirPath: parentDir
+			};
+		}
+	}
+	static async scanDirectoryForRepositories(argPath) {
+		let userRepo = null;
+		const [pathIsRepo] = await describeAsyncJob({
+			job: () => GitCaller.isGitRepo(argPath),
+			beforeMsg: "Checking if path is a git repo...",
+			afterMsg: "Done checking if path is a git repo",
+			errorMsg: "Error checking if path is a git repo"
+		});
+		const baseDir = resolve(pathIsRepo ? getBaseDirFromPath(argPath) : argPath);
+		const entries = await promises.readdir(baseDir, { withFileTypes: true });
+		const dirs = entries.filter((entry) => entry.isDirectory()).map(({ name }) => name);
+		const [repoResults] = await describeAsyncJob({
+			job: () => Promise.allSettled(dirs.map(async (repo) => {
+				const result = await GitCaller.getRepoMetadata(join(baseDir, repo));
+				if (!result) throw Error("Not a git repo");
+				return result;
+			})),
+			beforeMsg: "Scanning for repositories...",
+			afterMsg: "Done scanning for repositories",
+			errorMsg: "Error scanning for repositories"
+		});
+		const onlyRepos = repoResults.filter((currentRepo) => {
+			if (currentRepo.status === "rejected") return false;
+			if (pathIsRepo && currentRepo.value.name === getDirName(argPath)) userRepo = currentRepo.value;
+			return true;
+		}).map((result) => result.value);
+		return [userRepo, onlyRepos];
+	}
+	static parseRefs(refsAsMultilineString) {
+		const gitRefs = {
+			Branches: {},
+			Tags: {}
+		};
+		const regex = /^(?<hash>.*) refs\/(?<ref_type>.*?)\/(?<path>.*)$/gm;
+		const matches = refsAsMultilineString.matchAll(regex);
+		let next = matches.next();
+		while (next.value) {
+			const groups = next.value.groups;
+			if (!groups) break;
+			next = matches.next();
+			const hash = groups["hash"];
+			const ref_type = groups["ref_type"];
+			const path$1 = groups["path"];
+			switch (ref_type) {
+				case "heads":
+					gitRefs.Branches[path$1] = hash;
+					break;
+				case "remotes": break;
+				case "tags":
+					gitRefs.Tags[path$1] = hash;
+					break;
+				default: break;
+			}
+		}
+		gitRefs.Branches = Object.fromEntries(Object.entries(gitRefs.Branches).sort(([a], [b]) => branchCompare(a, b)));
+		gitRefs.Tags = Object.fromEntries(Object.entries(gitRefs.Tags).sort(([a], [b]) => semverCompare(a, b) * -1));
+		return gitRefs;
+	}
+	async gitLog(skip, count) {
+		const args = [
+			"log",
+			`--skip=${skip}`,
+			`--max-count=${count}`,
+			this.branch,
+			"--summary",
+			"--numstat",
+			"--format=\"author <|%aN|> date <|%ct %at|> message <|%s|> body <|%b|> hash <|%H|>\""
+		];
+		const result = await runProcess(this.repoPath, "git", args);
+		return result.trim();
+	}
+	async gitLogSimple(skip, count, instance, index) {
+		const args = [
+			"log",
+			`--skip=${skip}`,
+			`--max-count=${count}`,
+			this.branch,
+			"--summary",
+			"--numstat",
+			"--format=\"<|%aN|><|%ct %at|><|%H|>\""
+		];
+		const result = await runProcess(this.repoPath, "git", args, instance, index);
+		return result.trim();
+	}
+	static async retrieveCachedResult({ repo, branch, branchHead }) {
+		const reasons = [];
+		const cachedDataPath = GitCaller.getCachePath(repo, branch);
+		if (!existsSync(cachedDataPath)) return [null, [ANALYZER_CACHE_MISS_REASONS.NOT_CACHED]];
+		const cachedData = JSON.parse(await promises.readFile(cachedDataPath, "utf8"));
+		const branchHeadMatches = branchHead === cachedData.commit.hash;
+		if (!branchHeadMatches) reasons.push(ANALYZER_CACHE_MISS_REASONS.BRANCH_HEAD_CHANGED);
+		const dataVersionMatches = cachedData.interfaceVersion === AnalyzerDataInterfaceVersion;
+		if (!branchHeadMatches) reasons.push(ANALYZER_CACHE_MISS_REASONS.DATA_VERSION_MISMATCH);
+		const repoMatches = repo === cachedData.repo;
+		const cacheConditions = {
+			branchHeadMatches,
+			dataVersionMatches,
+			repoMatches
+		};
+		if (!Object.values(cacheConditions).every(Boolean)) return [null, reasons];
+		return [cachedData, reasons];
+	}
+	setUseCache(useCache) {
+		this.useCache = useCache;
+	}
+	async commitCountSinceCommit(hash, branch) {
+		const result = await runProcess(this.repoPath, "git", [
+			"rev-list",
+			"--count",
+			`${hash}..${branch}`
+		]);
+		return result;
+	}
+	async getRefs() {
+		return await GitCaller._getRefs(this.repo);
+	}
+	static async _getRefs(repo) {
+		const result = await runProcess(repo, "git", ["show-ref"]);
+		return result;
+	}
+	async catFile(hash) {
+		const result = await runProcess(this.repoPath, "git", [
+			"cat-file",
+			"-p",
+			hash
+		]);
+		return result;
+	}
+	async findBranchHead() {
+		return await GitCaller.findBranchHead(this.repoPath, this.branch);
+	}
+	async catFileCached(hash) {
+		if (this.useCache) {
+			const cachedValue = this.catFileCache.get(hash);
+			if (cachedValue) return cachedValue;
+		}
+		const result = await this.catFile(hash);
+		this.catFileCache.set(hash, result);
+		return result;
+	}
+	async getCommitCount() {
+		const result = await runProcess(this.repoPath, "git", [
+			"rev-list",
+			"--count",
+			this.branch
+		]);
+		return result;
+	}
+	async getDefaultGitSettingValue(setting) {
+		const result = await runProcess(this.repoPath, "git", ["config", setting]);
+		return result;
+	}
+	async resetGitSetting(settingToReset, value) {
+		if (!value) {
+			await runProcess(this.repoPath, "git", [
+				"config",
+				"--unset",
+				settingToReset
+			]);
+			log.debug(`Unset ${settingToReset}`);
+		} else {
+			await runProcess(this.repoPath, "git", [
+				"config",
+				settingToReset,
+				value
+			]);
+			log.debug(`Reset ${settingToReset} to ${value}`);
+		}
+	}
+	async setGitSetting(setting, value) {
+		await runProcess(this.repoPath, "git", [
+			"config",
+			setting,
+			value
+		]);
+		log.debug(`Set ${setting} to ${value}`);
+	}
+};
+const gitLogRegex = /"author\s+<\|(?<author>.*?)\|>\s+date\s+<\|(?<datecommitter>\d+)\s(?<dateauthor>\d+)\|>\s+message\s+<\|(?<message>[\s\S]*?)\|>\s+body\s+<\|(?<body>[\s\S]*?)\|>\s+hash\s+<\|(?<hash>.+?)\|>"\s*(?<contributions>(?:(?:\d+|-)\s+(?:\d+|-)\s+.+\s?)*)(?<modes>(?:\s.+\s*)*)/gmu;
+const gitLogRegexSimple = /"<\|(?<author>.*?)\|><\|(?<datecommitter>\d+)\s(?<dateauthor>\d+)\|><\|(?<hash>.+?)\|>"\s*(?<contributions>(?:(?:\d+|-)\s+(?:\d+|-)\s+.+\s?)*)(?<modes>(?:\s.+\s*)*)/gmu;
+const contribRegex = /(?<insertions>\d+|-)\s+(?<deletions>\d+|-)\s+(?<file>.+)/gm;
+const treeRegex = /^\S+? (?<type>\S+) (?<hash>\S+)\s+(?<size>\S+)\s+(?<path>.+)/gm;
+const modeRegex = /\s(?<mode>\w+)\s\w+\s\d+\s(?<file>.+)/gmu;
+const OPTIONS_LOCAL_STORAGE_KEY = "options";
+var MetadataDB = class {
+	path = resolve$1(os.tmpdir(), "git-truck-cache", "metadata.json");
+	separator = "---";
+	async readMetadata() {
+		try {
+			const data = JSON.parse(await promises$1.readFile(this.path, "utf8"));
+			return data;
+		} catch (e) {
+			return {
+				completions: {},
+				authorcolors: {}
+			};
+		}
+	}
+	async setMetadata(newData) {
+		const asString = JSON.stringify(newData);
+		await promises$1.writeFile(this.path, asString, "utf8");
+	}
+	async setCompletion(repo, branch, hash) {
+		const currentMetadata = await this.readMetadata();
+		currentMetadata.completions[`${repo}${this.separator}${branch}`] = {
+			hash,
+			time: Math.floor(Date.now() / 1e3)
+		};
+		await this.setMetadata(currentMetadata);
+	}
+	async addAuthorColor(author, color) {
+		const currentMetadata = await this.readMetadata();
+		if (color === "") delete currentMetadata.authorcolors[author];
+		else currentMetadata.authorcolors[author] = color;
+		await this.setMetadata(currentMetadata);
+	}
+	async getAuthorColors() {
+		const currentMetadata = await this.readMetadata();
+		return currentMetadata.authorcolors;
+	}
+	async getLastRun(repo, branch) {
+		const currentMetadata = await this.readMetadata();
+		return currentMetadata.completions[`${repo}${this.separator}${branch}`];
+	}
+	async getCompletedRepos() {
+		const completedResults = [];
+		const currentMetadata = await this.readMetadata();
+		for (const [key, val] of Object.entries(currentMetadata.completions)) {
+			const [repo, branch] = key.split(this.separator);
+			completedResults.push({
+				repo,
+				branch,
+				time: val.time
+			});
+		}
+		return completedResults;
+	}
+};
+var InstanceManager = class {
+	static instances = /* @__PURE__ */ new Map();
+	static metadataDB;
+	static getOrCreateMetadataDB() {
+		if (!this.metadataDB) this.metadataDB = new MetadataDB();
+		return this.metadataDB;
+	}
+	static getOrCreateInstance(repo, branch, repoPath) {
+		if (!this.instances) this.instances = /* @__PURE__ */ new Map();
+		const existing = this.instances.get(repo)?.get(branch);
+		if (existing) return existing;
+		const newInstance = new ServerInstance(repo, branch, repoPath);
+		const existingRepo = this.instances.get(repo);
+		if (existingRepo) existingRepo.set(branch, newInstance);
+		else this.instances.set(repo, new Map([[branch, newInstance]]));
+		return newInstance;
+	}
+	static getInstance(repo, branch) {
+		if (!this.instances) this.instances = /* @__PURE__ */ new Map();
+		return this.instances.get(repo)?.get(branch);
+	}
+	static async closeAllDBConnections() {
+		const promises$2 = Array.from(this.instances.values()).flatMap((repoInstance) => Array.from(repoInstance.values()).flatMap((branchInstance) => branchInstance.db.disconnect()));
+		await Promise.all(promises$2);
+		this.instances = /* @__PURE__ */ new Map();
+	}
+};
+var ServerInstance = class {
+	analyzationStatus = "Starting";
+	gitCaller;
+	db;
+	progress = [0];
+	totalCommitCount = 0;
+	fileTreeAsOf = null;
+	prevResult = null;
+	prevInvokeReason = "unknown";
+	prevProgress = {
+		str: "",
+		timestamp: 0
+	};
+	constructor(repo, branch, repoPath) {
+		this.repo = repo;
+		this.branch = branch;
+		this.repoPath = repoPath;
+		this.gitCaller = new GitCaller(repo, branch, repoPath);
+		this.db = new DB(repo, branch);
+	}
+	updateProgress(index) {
+		this.progress[index]++;
+	}
+	async gathererWorker(sectionStart, sectionEnd, index) {
+		const CHUNK_SIZE = 7e4;
+		for (let start = sectionStart; start <= sectionEnd; start += CHUNK_SIZE) {
+			const end = Math.min(start + CHUNK_SIZE, sectionEnd);
+			const commits = /* @__PURE__ */ new Map();
+			const renamedFiles = [];
+			log.debug(`thread ${index} gathering ${start}-${end}`);
+			await this.gatherCommitsInRange(start, end, commits, renamedFiles, index);
+			await this.db.addRenames(renamedFiles);
+			await this.db.addCommits(commits);
+			this.progress[index] = end - sectionStart;
+		}
+	}
+	async updateTimeInterval(start, end) {
+		await this.db.updateTimeInterval(start, end);
+		this.fileTreeAsOf = await this.db.getLatestCommitHash(end);
+	}
+	async analyzeTree() {
+		if (!this.fileTreeAsOf) this.fileTreeAsOf = await this.db.getLatestCommitHash();
+		const rawContent = await this.gitCaller.lsTree(this.fileTreeAsOf);
+		const lsTreeEntries = [];
+		const matches = rawContent.matchAll(treeRegex);
+		let fileCount = 0;
+		for (const match of matches) {
+			if (!match.groups) continue;
+			const groups = match.groups;
+			lsTreeEntries.push({
+				type: groups["type"],
+				hash: groups["hash"],
+				size: groups["size"] === "-" ? void 0 : Number(groups["size"]),
+				path: this.repo + "/" + groups["path"]
+			});
+		}
+		const rootTree = {
+			type: "tree",
+			path: this.repo,
+			name: this.repo,
+			hash: this.fileTreeAsOf,
+			children: []
+		};
+		await this.db.replaceFiles(lsTreeEntries);
+		for (const child of lsTreeEntries) {
+			const prevTrees = child.path.split("/").slice(1);
+			const newName = prevTrees.pop();
+			const newPath = `${child.path}`;
+			let currTree = rootTree;
+			for (const treePath of prevTrees) {
+				const foundTree = currTree.children.find((t) => t.name === treePath && t.type === "tree");
+				if (!foundTree) continue;
+				currTree = foundTree;
+			}
+			switch (child.type) {
+				case "tree": {
+					const newTree = {
+						type: "tree",
+						path: newPath,
+						name: newName,
+						hash: child.hash,
+						children: []
+					};
+					currTree.children.push(newTree);
+					break;
+				}
+				case "blob": {
+					fileCount += 1;
+					const blob = {
+						type: "blob",
+						hash: child.hash,
+						path: newPath,
+						name: newName,
+						sizeInBytes: child.size
+					};
+					currTree.children.push(blob);
+					break;
+				}
+			}
+		}
+		this.treeCleanup(rootTree);
+		return {
+			rootTree,
+			fileCount
+		};
+	}
+	treeCleanup(tree) {
+		for (const child of tree.children) if (child.type === "tree") {
+			const ctree = child;
+			this.treeCleanup(ctree);
+		}
+		tree.children = tree.children.filter((child) => {
+			if (child.type === "blob") return true;
+			else {
+				const ctree = child;
+				if (ctree.children.length === 0) return false;
+				return true;
+			}
+		});
+		if (tree.children.length === 1 && tree.children[0].type === "tree") {
+			const temp = tree.children[0];
+			tree.children = temp.children;
+			tree.name = `${tree.name}/${temp.name}`;
+			tree.path = `${tree.path}/${temp.name}`;
+		}
+	}
+	async gatherCommitsFromGitLog(gitLogResult, commits, renamedFiles) {
+		const matches = gitLogResult.matchAll(gitLogRegexSimple);
+		const FileModifications = [];
+		for (const match of matches) {
+			const groups = match.groups ?? {};
+			const author = groups.author;
+			const committertime = Number(groups.datecommitter);
+			const authortime = Number(groups.dateauthor);
+			const hash = groups.hash;
+			const contributionsString = groups.contributions;
+			const modesString = groups.modes;
+			const fileChanges = [];
+			if (modesString) {
+				const modeMatches = modesString.matchAll(modeRegex);
+				for (const modeMatch of modeMatches) {
+					const file = modeMatch.groups?.file.trim();
+					const mode = modeMatch.groups?.mode.trim();
+					if (!file || !mode) continue;
+					if (mode === "delete" || mode === "create") FileModifications.push({
+						path: file,
+						timestamp: committertime,
+						timestampauthor: authortime,
+						type: mode
+					});
+				}
+			}
+			if (contributionsString) {
+				const contribMatches = contributionsString.matchAll(contribRegex);
+				for (const contribMatch of contribMatches) {
+					const file = contribMatch.groups?.file.trim();
+					const isBinary = contribMatch.groups?.insertions === "-";
+					if (!file) throw Error("file not found");
+					const fileHasMoved = file.includes("=>");
+					let filePath = file;
+					if (fileHasMoved) filePath = analyzeRenamedFile(file, committertime, authortime, renamedFiles, this.repo);
+					const insertions = isBinary ? 1 : Number(contribMatch.groups?.insertions ?? "0");
+					const deletions = isBinary ? 0 : Number(contribMatch.groups?.deletions ?? "0");
+					fileChanges.push({
+						isBinary,
+						insertions,
+						deletions,
+						path: this.repo + "/" + filePath,
+						mode: "modify"
+					});
+				}
+			}
+			commits.set(hash, {
+				author,
+				committertime,
+				authortime,
+				hash,
+				coauthors: [],
+				fileChanges
+			});
+		}
+		renamedFiles.push(...FileModifications.map((modification) => {
+			if (modification.type === "delete") return {
+				fromname: modification.path,
+				toname: null,
+				timestamp: modification.timestamp,
+				timestampauthor: modification.timestampauthor
+			};
+			return {
+				fromname: null,
+				toname: modification.path,
+				timestamp: modification.timestamp,
+				timestampauthor: modification.timestampauthor
+			};
+		}));
+	}
+	async getFullCommits(gitLogResult) {
+		const commits = [];
+		const matches = gitLogResult.matchAll(gitLogRegex);
+		for (const match of matches) {
+			const groups = match.groups ?? {};
+			const author = groups.author;
+			const message = groups.message;
+			const body = groups.body;
+			const committertime = Number(groups.datecommitter);
+			const authortime = Number(groups.dateauthor);
+			const hash = groups.hash;
+			const contributionsString = groups.contributions;
+			const fileChanges = [];
+			if (contributionsString) {
+				const contribMatches = contributionsString.matchAll(contribRegex);
+				for (const contribMatch of contribMatches) {
+					const file = contribMatch.groups?.file.trim();
+					const isBinary = contribMatch.groups?.insertions === "-";
+					if (!file) throw Error("file not found");
+					const insertions = isBinary ? 1 : Number(contribMatch.groups?.insertions ?? "0");
+					const deletions = isBinary ? 0 : Number(contribMatch.groups?.deletions ?? "0");
+					fileChanges.push({
+						isBinary,
+						insertions,
+						deletions,
+						path: file,
+						mode: "modify"
+					});
+				}
+			}
+			commits.push({
+				author,
+				committertime,
+				authortime,
+				hash,
+				fileChanges,
+				message,
+				body
+			});
+		}
+		return commits;
+	}
+	async gatherCommitsInRange(start, end, commits, renamedFiles, index) {
+		const gitLogResult = await this.gitCaller.gitLogSimple(start, end - start, this, index);
+		await this.gatherCommitsFromGitLog(gitLogResult, commits, renamedFiles);
+		log.debug("done gathering");
+	}
+	flattenChains(chains) {
+		return chains.flatMap((chain) => {
+			const destinationName = chain[0].toname;
+			return chain.map((interval) => ({
+				...interval,
+				toname: destinationName
+			}));
+		});
+	}
+	async updateRenames() {
+		const rawRenames = await this.db.getCurrentRenameIntervals();
+		const files = await this.db.getFiles();
+		const renameChains = this.generateRenameChains(rawRenames, files);
+		const flattenedRenames = this.flattenChains(renameChains);
+		await this.db.replaceTemporaryRenames(flattenedRenames);
+	}
+	generateRenameChains(orderedRenames, currentFiles) {
+		const currentPathToRenameChain = /* @__PURE__ */ new Map();
+		const finishedChains = [];
+		for (const file of currentFiles) currentPathToRenameChain.set(file, [{
+			fromname: file,
+			toname: file,
+			timestamp: 0,
+			timestampend: 4e9
+		}]);
+		for (const rename of orderedRenames) {
+			if (rename.toname === null) continue;
+			const existing = currentPathToRenameChain.get(rename.toname);
+			if (existing) {
+				const prevRename = existing[existing.length - 1];
+				prevRename.timestamp = rename.timestampend;
+				if (rename.fromname !== null) {
+					existing.push(rename);
+					currentPathToRenameChain.set(rename.fromname, existing);
+				} else {
+					prevRename.timestamp = rename.timestampend;
+					finishedChains.push(existing);
+				}
+				currentPathToRenameChain.delete(rename.toname);
+			}
+		}
+		finishedChains.push(...currentPathToRenameChain.values());
+		return finishedChains;
+	}
+	getThreadCount(repoCommitCount) {
+		const estimatedBytesPerCommit = 1300;
+		const minimumBytesPerThread = 4e8;
+		const systemMemoryToNotUse = 8e8;
+		const threadsToNotUse = 2;
+		const availableMemory = process.platform === "linux" || process.platform === "win32" ? freemem() - systemMemoryToNotUse : Math.floor(totalmem() / 2) - systemMemoryToNotUse;
+		const availableThreadCount = Math.min(Math.max(cpus().length - threadsToNotUse, 2), 4);
+		if (availableMemory < 1) return availableThreadCount;
+		const estimatedBytesPerThread = Math.max(estimatedBytesPerCommit * repoCommitCount, minimumBytesPerThread);
+		const threadsBasedOnMemory = Math.floor(availableMemory / estimatedBytesPerThread);
+		return Math.max(2, Math.min(availableThreadCount, threadsBasedOnMemory));
+	}
+	calculateSections(commitCount, threadCount) {
+		const sections = [];
+		if (threadCount === 2) {
+			const section1Size = Math.floor(commitCount * 53 / 100);
+			sections.push([0, section1Size]);
+			sections.push([section1Size, commitCount]);
+		} else if (threadCount === 3) {
+			const section1Size = Math.floor(commitCount * 35 / 100);
+			const section2Size = Math.floor(commitCount * 33 / 100);
+			sections.push([0, section1Size]);
+			sections.push([section1Size, section1Size + section2Size]);
+			sections.push([section1Size + section2Size, commitCount]);
+		} else if (threadCount === 4) {
+			const section1Size = Math.floor(commitCount * 27 / 100);
+			const section2Size = Math.floor(commitCount * 26 / 100);
+			const section3Size = Math.floor(commitCount * 24 / 100);
+			sections.push([0, section1Size]);
+			sections.push([section1Size, section1Size + section2Size]);
+			sections.push([section1Size + section2Size, section1Size + section2Size + section3Size]);
+			sections.push([section1Size + section2Size + section3Size, commitCount]);
+		} else throw new Error("Invalid threadCount. Only 2, 3, or 4 are allowed.");
+		return sections;
+	}
+	async loadRepoData() {
+		this.analyzationStatus = "Starting";
+		let commitCount = await this.gitCaller.getCommitCount();
+		const priorRun = await InstanceManager.getOrCreateMetadataDB().getLastRun(this.repo, this.branch);
+		if (!await this.db.commitTableEmpty()) if (priorRun) {
+			const latestCommit = await this.db.getLatestCommitHash();
+			commitCount = await this.gitCaller.commitCountSinceCommit(latestCommit, this.branch);
+			log.info(`Repo has been analyzed previously, only analzying ${commitCount} commits`);
+		} else {
+			log.warn("Incomplete database found. Clearing and running complete analysis.");
+			await this.db.clearAllTables();
+		}
+		if (commitCount < 1) return;
+		const quotePathDefaultValue = await this.gitCaller.getDefaultGitSettingValue("core.quotepath");
+		await this.gitCaller.setGitSetting("core.quotePath", "off");
+		const renamesDefaultValue = await this.gitCaller.getDefaultGitSettingValue("diff.renames");
+		await this.gitCaller.setGitSetting("diff.renames", "true");
+		const renameLimitDefaultValue = await this.gitCaller.getDefaultGitSettingValue("diff.renameLimit");
+		await this.gitCaller.setGitSetting("diff.renameLimit", "1000000");
+		this.totalCommitCount = commitCount;
+		const threadCount = this.getThreadCount(commitCount);
+		this.progress = Array(threadCount).fill(0);
+		this.analyzationStatus = "Hydrating";
+		const sections = this.calculateSections(commitCount, threadCount);
+		const promises$2 = Array.from({ length: threadCount }, async (_, i) => {
+			const sectionStart = sections[i][0];
+			const sectionEnd = sections[i][1];
+			log.debug("start thread " + sectionStart + "-" + sectionEnd + ", " + i);
+			await this.gathererWorker(sectionStart, sectionEnd, i);
+			log.debug("finished thread: " + i);
+		});
+		await Promise.all(promises$2);
+		await this.db.createIndexes();
+		await this.db.checkpoint();
+		await this.gitCaller.resetGitSetting("core.quotepath", quotePathDefaultValue);
+		await this.gitCaller.resetGitSetting("diff.renames", renamesDefaultValue);
+		await this.gitCaller.resetGitSetting("diff.renameLimit", renameLimitDefaultValue);
+		await InstanceManager.getOrCreateMetadataDB().setCompletion(this.repo, this.branch, await this.db.getLatestCommitHash());
+		this.analyzationStatus = "GeneratingChart";
+	}
+};
+function runProcess(dir, command, args, serverInstance, index) {
+	log.debug(`exec ${dir} $ ${command} ${args.join(" ")}`);
+	return new Promise((resolve$2, reject) => {
+		try {
+			const prcs = spawn(command, args, { cwd: path.resolve(dir) });
+			const chunks = [];
+			const errorHandler = (buf) => reject(buf.toString().trim());
+			prcs.once("error", errorHandler);
+			prcs.stderr.once("data", errorHandler);
+			prcs.stdout.on("data", (buf) => {
+				chunks.push(buf);
+				if (serverInstance && index !== void 0) serverInstance.updateProgress(index);
+			});
+			prcs.stdout.on("end", () => {
+				resolve$2(Buffer.concat(chunks).toString().trim());
+			});
+		} catch (e) {
+			log.error(e);
+			reject(e);
+		}
+	});
+}
+function generateTruckFrames(length) {
+	const frames = [];
+	for (let i = 0; i < length; i++) {
+		const prefix$1 = " ".repeat(length - i - 1);
+		const frame = `${prefix$1}🚛\n`;
+		frames.push(frame);
+	}
+	return frames;
+}
+function createTruckSpinner() {
+	return getLogLevel() === null ? createSpinner("", {
+		interval: 1e3 / 20,
+		frames: generateTruckFrames(20)
+	}) : null;
+}
+let spinner = null;
+/**
+
+* This function is a wrapper around a job that provides a spinner and logs the result of the job.
+
+* @returns
+
+*/
+async function describeAsyncJob({ job = async () => null, beforeMsg = "", afterMsg = "", errorMsg = "", ms = null }) {
+	spinner = createTruckSpinner();
+	const success = (text, final = false) => {
+		if (getLogLevel() === LOG_LEVEL.SILENT) return;
+		if (spinner === null) return log.info(text);
+		spinner.success({ text });
+		if (!final) spinner.start();
+	};
+	const output = (text) => {
+		if (spinner) {
+			spinner.update({
+				text,
+				frames: generateTruckFrames(text.length)
+			});
+			spinner.start();
+		} else log.info(text);
+	};
+	const error$1 = (text) => spinner === null ? log.error(text) : spinner.error({ text });
+	if (beforeMsg.length > 0) output(beforeMsg);
+	try {
+		const startTime = performance.now();
+		const result = await job();
+		const stopTime = performance.now();
+		const suffix = c.gray(`${formatMs(!ms ? stopTime - startTime : ms)}`);
+		success(`${afterMsg} ${suffix}`, true);
+		return [result, null];
+	} catch (e) {
+		error$1(errorMsg);
+		log.error(e);
+		return [null, e];
+	}
+}
+function getCommandLine() {
+	switch (process.platform) {
+		case "darwin": return "open";
+		case "win32": return "start \"\"";
+		default: return "xdg-open";
+	}
+}
+function openFile(repoDir, repoPath) {
+	repoPath = path.resolve(repoDir, "..", repoPath.split("/").join("/"));
+	const command = `${getCommandLine()} "${repoPath}"`;
+	exec(command).stderr?.on("data", (e) => {
+		log.error(`Cannot open file ${path.resolve(repoDir, repoPath)}: ${e}`);
+	});
+}
+let latestVersion = null;
+async function getLatestVersion() {
+	if (!latestVersion) {
+		const [result] = await promiseHelper(fetch("https://registry.npmjs.org/-/package/git-truck/dist-tags").then((res) => res.json()).then((pkg) => pkg.latest));
+		latestVersion = result;
+	}
+	return latestVersion;
+}
+const readGitRepos = async (baseDir) => {
+	const entries = await readdir(baseDir, { withFileTypes: true });
+	return entries.filter((entry) => entry.isDirectory() && existsSync(path.join(baseDir, entry.name)) && !entry.name.startsWith(".") && existsSync(path.join(baseDir, entry.name, ".git"))).map(({ name }) => ({
+		name,
+		path: path.join(baseDir, name),
+		parentDirPath: baseDir,
+		status: "Loading"
+	}));
+};
+function parseArgs(rawArgs = process.argv.slice(2)) {
+	return yargsParser(rawArgs, { configuration: { "duplicate-arguments-array": false } });
+}
+function getArgsWithDefaults() {
+	const args = parseArgs();
+	const tempArgs = {
+		path: ".",
+		...args
+	};
+	return tempArgs;
+}
+async function getArgs() {
+	const args = getArgsWithDefaults();
+	const pathIsRepo = await GitCaller.isGitRepo(args.path);
+	args.path = pathIsRepo ? getBaseDirFromPath(args.path) : args.path;
+	return args;
+}
+const getBaseDirFromPath = (repoPath) => path.resolve(repoPath, "..");
+function getDirName(repoPath) {
+	return path.basename(path.resolve(repoPath));
+}
+export { DB, GitCaller, InstanceManager, OPTIONS_LOCAL_STORAGE_KEY, allExceptFirst, allExceptLast, dateFormatCalendarHeader, dateFormatLong, dateFormatRelative, dateFormatShort, dateTimeFormatShort, generateVersionComparisonLink, getArgs, getArgsWithDefaults, getBaseDirFromPath, getDirName, getLatestVersion, getLightness, getPathFromRepoAndHead, getSeparator, hslToHex, invariant, isBlob, isDarkColor, isTree, last, log, numToFriendlyString, openFile, promiseHelper, readGitRepos, semverCompare, sleep };