git-truck 0.8.1 → 0.8.4-1

package/.github/workflows/bump-version.yml

@@ -31,7 +31,7 @@ jobs:
           env:
             GITHUB_TOKEN: ${{ secrets.TOKEN }}
 
-        - run: npm install --package-lock-only
+        - run: npm install --package-lock-only --ignore-scripts
         - run: git add package-lock.json
         - run: git config user.email "version-bot@example.com"
         - run: git config user.name "Version Bot"

package/build/index.js

@@ -4383,7 +4383,7 @@ function parents(obj) {
 async function diffAndUpdate_mut(data, currCommit, parentHash) {
   const { author } = currCommit;
   const currHash = currCommit.hash;
-  log.debug(`comparing [${currHash}] -> [${parentHash}]`);
+  log.debug(`comparing aaaa [${currHash}] -> [${parentHash}]`);
   const fileChanges = await gitDiffNumStatAnalyzed(parentHash, currHash, renamedFiles);
   for (const fileChange of fileChanges) {
     const { pos, neg, file } = fileChange;
@@ -5533,7 +5533,7 @@ async function latestVersion(packageName, options) {
 
 // package.json
 var name = "git-truck";
-var version = "0.8.0";
+var version = "0.8.4-0";
 var private2 = false;
 var description = "Visualizing a Git repository";
 var license = "MIT";
@@ -5546,6 +5546,7 @@ var scripts = {
   build: "remix setup node && cross-env NODE_ENV=production remix build && node ./post-build.js",
   dev: "cross-env NODE_ENV=development remix build && node dev.js",
   "dev:remix": "cross-env NODE_ENV=development remix watch",
+  postinstall: "npm run build",
   "dev:node": "cross-env NODE_ENV=development nodemon --watch ./build/index.js ./build/index.js --",
   start: "cross-env NODE_ENV=production node ./build/index.js",
   format: "eslint --cache --fix src/**/*.{ts,tsx} && prettier --loglevel warn --write src/**/*.{ts,tsx}"
@@ -5703,7 +5704,9 @@ async function findBranchHead(repo, branch) {
 async function analyzeCommitLight(hash) {
   const rawContent = await GitCaller.getInstance().catFileCached(hash);
   const commitRegex = /tree (?<tree>.*)\s*(?:parent (?<parent>.*)\s*)?(?:parent (?<parent2>.*)\s*)?author (?<authorName>.*?) <(?<authorEmail>.*?)> (?<authorTimeStamp>\d*?) (?<authorTimeZone>.*?)\s*committer (?<committerName>.*?) <(?<committerEmail>.*?)> (?<committerTimeStamp>\d*?) (?<committerTimeZone>.*)\s*(?:gpgsig (?:.|\s)*?-----END PGP SIGNATURE-----)?\s*(?<message>.*)\s*(?<description>(?:.|\s)*)/gm;
+  log.debug("before match");
   const match = commitRegex.exec(rawContent);
+  log.debug("after match: " + JSON.stringify(match));
   const groups = (match == null ? void 0 : match.groups) ?? {};
   const tree = groups["tree"];
   const parent = groups["parent"] ?? emptyGitCommitHash;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-truck",
-  "version": "0.8.1",
+  "version": "0.8.4-1",
   "private": false,
   "description": "Visualizing a Git repository",
   "license": "MIT",
@@ -13,6 +13,7 @@
     "build": "remix setup node && cross-env NODE_ENV=production remix build && node ./post-build.js",
     "dev": "cross-env NODE_ENV=development remix build && node dev.js",
     "dev:remix": "cross-env NODE_ENV=development remix watch",
+    "postinstall": "npm run build",
     "dev:node": "cross-env NODE_ENV=development nodemon --watch ./build/index.js ./build/index.js --",
     "start": "cross-env NODE_ENV=production node ./build/index.js",
     "format": "eslint --cache --fix src/**/*.{ts,tsx} && prettier --loglevel warn --write src/**/*.{ts,tsx}"

package/src/analyzer/analyze.server.ts

@@ -1,321 +1,322 @@
-import fsSync, { promises as fs } from "fs"
-import {
-  GitBlobObject,
-  GitCommitObject,
-  GitCommitObjectLight,
-  GitTreeObject,
-  AnalyzerData,
-  AnalyzerDataInterfaceVersion,
-  TruckUserConfig,
-} from "./model"
-import { log, setLogLevel } from "./log.server"
-import {
-  describeAsyncJob,
-  formatMs,
-  writeRepoToFile,
-  getCurrentBranch,
-  getRepoName,
-  getDefaultGitSettingValue,
-  resetGitSetting,
-  setGitSetting,
-} from "./util"
-import { GitCaller } from "./git-caller"
-import { emptyGitCommitHash } from "./constants"
-import { resolve, isAbsolute, join } from "path"
-import { performance } from "perf_hooks"
-import { getAuthorSet, hydrateData } from "./hydrate.server"
-import {} from "@remix-run/node"
-import { getArgs } from "./args.server"
-import ignore from "ignore"
-import { applyIgnore, applyMetrics, initMetrics, TreeCleanup } from "./postprocessing.server"
-import latestVersion from "latest-version"
-import pkg from "../../package.json"
-import { getCoAuthors } from "./coauthors.server"
-import { exec } from "child_process"
-
-let repoDir = "."
-
-export async function findBranchHead(repo: string, branch: string | null) {
-  if (branch === null) branch = await getCurrentBranch(repo)
-
-  const gitFolder = join(repo, ".git")
-  if (!fsSync.existsSync(gitFolder)) {
-    throw Error(`${repo} is not a git repository`)
-  }
-  // Find file containing the branch head
-  const branchPath = join(gitFolder, "refs/heads/" + branch)
-  const absolutePath = join(process.cwd(), branchPath)
-  log.debug("Looking for branch head at " + absolutePath)
-
-  const branchHead = (await fs.readFile(branchPath, "utf-8")).trim()
-  log.debug(`${branch} -> [commit]${branchHead}`)
-  if (!branchHead) throw Error("Branch head not found")
-
-  return [branchHead, branch]
-}
-
-export async function analyzeCommitLight(hash: string): Promise<GitCommitObjectLight> {
-  const rawContent = await GitCaller.getInstance().catFileCached(hash)
-  const commitRegex =
-    /tree (?<tree>.*)\s*(?:parent (?<parent>.*)\s*)?(?:parent (?<parent2>.*)\s*)?author (?<authorName>.*?) <(?<authorEmail>.*?)> (?<authorTimeStamp>\d*?) (?<authorTimeZone>.*?)\s*committer (?<committerName>.*?) <(?<committerEmail>.*?)> (?<committerTimeStamp>\d*?) (?<committerTimeZone>.*)\s*(?:gpgsig (?:.|\s)*?-----END PGP SIGNATURE-----)?\s*(?<message>.*)\s*(?<description>(?:.|\s)*)/gm
-
-  const match = commitRegex.exec(rawContent)
-  const groups = match?.groups ?? {}
-
-  const tree = groups["tree"]
-  const parent = groups["parent"] ?? emptyGitCommitHash
-  const parent2 = groups["parent2"] ?? null
-  const author = {
-    name: groups["authorName"],
-    email: groups["authorEmail"],
-    timestamp: Number(groups["authorTimeStamp"]),
-    timezone: groups["authorTimeZone"],
-  }
-  const committer = {
-    name: groups["committerName"],
-    email: groups["committerEmail"],
-    timestamp: Number(groups["committerTimeStamp"]),
-    timezone: groups["committerTimeZone"],
-  }
-  const message = groups["message"]
-  const description = groups["description"]
-  const coauthors = description ? getCoAuthors(description) : []
-
-  return {
-    type: "commit",
-    hash,
-    tree,
-    parent,
-    parent2,
-    author,
-    committer,
-    message,
-    description,
-    coauthors,
-  }
-}
-
-export async function analyzeCommit(repoName: string, hash: string): Promise<GitCommitObject> {
-  if (hash === undefined) {
-    throw Error("Hash is required")
-  }
-  const { tree, ...commit } = await analyzeCommitLight(hash)
-  const commitObject = {
-    ...commit,
-    tree: await analyzeTree(repoName, repoName, tree),
-  }
-  return commitObject
-}
-
-async function analyzeTree(path: string, name: string, hash: string): Promise<GitTreeObject> {
-  const rawContent = await GitCaller.getInstance().catFileCached(hash)
-  const entries = rawContent.split("\n").filter((x) => x.trim().length > 0)
-
-  const children: (GitTreeObject | GitBlobObject)[] = []
-  for await (const line of entries) {
-    const catFileRegex = /^.+?\s(?<type>\w+)\s(?<hash>.+?)\s+(?<name>.+?)\s*$/g
-    const groups = catFileRegex.exec(line)?.groups ?? {}
-
-    const type = groups["type"]
-    const hash = groups["hash"]
-    const name = groups["name"]
-
-    const newPath = [path, name].join("/")
-    log.debug(`Path: ${newPath}`)
-
-    switch (type) {
-      case "tree":
-        children.push(await analyzeTree(newPath, name, hash))
-        break
-      case "blob":
-        children.push({
-          type: "blob",
-          hash,
-          path: newPath,
-          name,
-          content: await GitCaller.getInstance().catFileCached(hash),
-          blameAuthors: await GitCaller.getInstance().parseBlame(newPath),
-        })
-        break
-      default:
-        throw new Error(` type ${type}`)
-    }
-  }
-
-  return {
-    type: "tree",
-    path,
-    name,
-    hash,
-    children,
-  }
-}
-
-function getCommandLine() {
-  switch (process.platform) {
-    case "darwin":
-      return "open" // MacOS
-    case "win32":
-      return "start" // Windows
-    default:
-      return "xdg-open" // Linux
-  }
-}
-
-export function openFile(path: string) {
-  path = path.split("/").slice(1).join("/") ?? path.split("\\").slice(1).join("\\")
-  exec(`${getCommandLine()} ${resolve(repoDir, path)}`).stderr?.on("data", (e) => {
-    // TODO show error in UI
-    log.error(`Cannot open file ${resolve(repoDir, path)}: ${e}`)
-  })
-}
-
-export async function updateTruckConfig(repoDir: string, updaterFn: (tc: TruckUserConfig) => TruckUserConfig) {
-  const truckConfigPath = resolve(repoDir, "truckconfig.json")
-  let currentConfig: TruckUserConfig = {}
-  try {
-    const configFileContents = await fs.readFile(truckConfigPath, "utf-8")
-    if (configFileContents) currentConfig = JSON.parse(configFileContents)
-  } catch (e) {}
-  const updatedConfig = updaterFn(currentConfig)
-  await fs.writeFile(truckConfigPath, JSON.stringify(updatedConfig, null, 2))
-}
-
-export async function analyze(useCache = true) {
-  const args = await getArgs()
-  GitCaller.initInstance(args.path)
-
-  if (args?.log) {
-    setLogLevel(args.log as string)
-  }
-
-  repoDir = args.path
-  if (!isAbsolute(repoDir)) repoDir = resolve(process.cwd(), repoDir)
-
-  const branch = args.branch
-
-  const hiddenFiles = args.hiddenFiles
-
-  const start = performance.now()
-  const [branchHead, branchName] = await describeAsyncJob(
-    () => findBranchHead(repoDir, branch),
-    "Finding branch head",
-    "Found branch head",
-    "Error finding branch head"
-  )
-  const repoName = getRepoName(repoDir)
-
-  let data: AnalyzerData | null = null
-
-  const dataPath = getOutPathFromRepoAndBranch(repoName, branchName)
-  if (fsSync.existsSync(dataPath)) {
-    const path = getOutPathFromRepoAndBranch(repoName, branchName)
-    const cachedData = JSON.parse(await fs.readFile(path, "utf8")) as AnalyzerData
-
-    // Check if the current branchHead matches the hash of the analyzed commit from the cache
-    const branchHeadMatches = branchHead === cachedData.commit.hash
-
-    // Check if the data uses the most recent analyzer data interface
-    const dataVersionMatches = cachedData.interfaceVersion === AnalyzerDataInterfaceVersion
-
-    const cacheConditions = {
-      branchHeadMatches,
-      dataVersionMatches,
-      refresh: !useCache,
-    }
-
-    // Only return cached data if every criteria is met
-    if (Object.values(cacheConditions).every(Boolean)) {
-      data = {
-        ...cachedData,
-        hiddenFiles,
-      }
-    } else {
-      const reasons = Object.entries(cacheConditions)
-        .filter(([, value]) => !value)
-        .map(([key, value]) => `${key}: ${value}`)
-        .join(", ")
-      log.info(`Reanalyzing, since the following cache conditions were not met: ${reasons}`)
-    }
-  }
-
-  if (data === null) {
-    const quotePathDefaultValue = await getDefaultGitSettingValue(repoDir, "core.quotepath")
-    await setGitSetting(repoDir, "core.quotePath", "off")
-    const renamesDefaultValue = await getDefaultGitSettingValue(repoDir, "diff.renames")
-    await setGitSetting(repoDir, "diff.renames", "true")
-    const renameLimitDefaultValue = await getDefaultGitSettingValue(repoDir, "diff.renameLimit")
-    await setGitSetting(repoDir, "diff.renameLimit", "1000000")
-
-    const runDateEpoch = Date.now()
-    const repoTree = await describeAsyncJob(
-      () => analyzeCommit(repoName, branchHead),
-      "Analyzing commit tree",
-      "Commit tree analyzed",
-      "Error analyzing commit tree"
-    )
-
-    const hydratedRepoTree = await describeAsyncJob(
-      () => hydrateData(repoDir, repoTree),
-      "Hydrating commit tree",
-      "Commit tree hydrated",
-      "Error hydrating commit tree"
-    )
-
-    await resetGitSetting(repoDir, "core.quotepath", quotePathDefaultValue)
-    await resetGitSetting(repoDir, "diff.renames", renamesDefaultValue)
-    await resetGitSetting(repoDir, "diff.renameLimit", renameLimitDefaultValue)
-
-    const defaultOutPath = getOutPathFromRepoAndBranch(repoName, branchName)
-    let outPath = resolve((args.out as string) ?? defaultOutPath)
-    if (!isAbsolute(outPath)) outPath = resolve(process.cwd(), outPath)
-
-    let latestV: string | undefined
-
-    try {
-      latestV = await latestVersion(pkg.name)
-    } catch {}
-
-    const authorUnions = args.unionedAuthors as string[][]
-    data = {
-      cached: false,
-      hiddenFiles,
-      authors: getAuthorSet(),
-      repo: repoName,
-      branch: branchName,
-      commit: hydratedRepoTree,
-      authorUnions: authorUnions,
-      interfaceVersion: AnalyzerDataInterfaceVersion,
-      currentVersion: pkg.version,
-      latestVersion: latestV,
-      lastRunEpoch: runDateEpoch,
-    }
-
-    await describeAsyncJob(
-      () =>
-        writeRepoToFile(outPath, {
-          ...data,
-          cached: true,
-        } as AnalyzerData),
-      "Writing data to file",
-      `Wrote data to ${resolve(outPath)}`,
-      `Error writing data to file ${outPath}`
-    )
-  }
-
-  const truckignore = ignore().add(hiddenFiles)
-  data.commit.tree = applyIgnore(data.commit.tree, truckignore)
-  TreeCleanup(data.commit.tree)
-  initMetrics(data)
-  data.commit.tree = applyMetrics(data, data.commit.tree)
-
-  const stop = performance.now()
-
-  log.raw(`\nDone in ${formatMs(stop - start)}`)
-
-  return data
-}
-
-export function getOutPathFromRepoAndBranch(repoName: string, branchName: string) {
-  return resolve(__dirname, "..", ".temp", repoName, `${branchName}.json`)
-}
+import fsSync, { promises as fs } from "fs"
+import {
+  GitBlobObject,
+  GitCommitObject,
+  GitCommitObjectLight,
+  GitTreeObject,
+  AnalyzerData,
+  AnalyzerDataInterfaceVersion,
+  TruckUserConfig,
+} from "./model"
+import { log, setLogLevel } from "./log.server"
+import {
+  describeAsyncJob,
+  formatMs,
+  writeRepoToFile,
+  getCurrentBranch,
+  getRepoName,
+  getDefaultGitSettingValue,
+  resetGitSetting,
+  setGitSetting,
+} from "./util"
+import { GitCaller } from "./git-caller"
+import { emptyGitCommitHash } from "./constants"
+import { resolve, isAbsolute, join } from "path"
+import { performance } from "perf_hooks"
+import { getAuthorSet, hydrateData } from "./hydrate.server"
+import {} from "@remix-run/node"
+import { getArgs } from "./args.server"
+import ignore from "ignore"
+import { applyIgnore, applyMetrics, initMetrics, TreeCleanup } from "./postprocessing.server"
+import latestVersion from "latest-version"
+import pkg from "../../package.json"
+import { getCoAuthors } from "./coauthors.server"
+import { exec } from "child_process"
+
+let repoDir = "."
+
+export async function findBranchHead(repo: string, branch: string | null) {
+  if (branch === null) branch = await getCurrentBranch(repo)
+
+  const gitFolder = join(repo, ".git")
+  if (!fsSync.existsSync(gitFolder)) {
+    throw Error(`${repo} is not a git repository`)
+  }
+  // Find file containing the branch head
+  const branchPath = join(gitFolder, "refs/heads/" + branch)
+  const absolutePath = join(process.cwd(), branchPath)
+  log.debug("Looking for branch head at " + absolutePath)
+
+  const branchHead = (await fs.readFile(branchPath, "utf-8")).trim()
+  log.debug(`${branch} -> [commit]${branchHead}`)
+  if (!branchHead) throw Error("Branch head not found")
+
+  return [branchHead, branch]
+}
+
+export async function analyzeCommitLight(hash: string): Promise<GitCommitObjectLight> {
+  const rawContent = await GitCaller.getInstance().catFileCached(hash)
+  const commitRegex =
+    /tree (?<tree>.*)\s*(?:parent (?<parent>.*)\s*)?(?:parent (?<parent2>.*)\s*)?author (?<authorName>.*?) <(?<authorEmail>.*?)> (?<authorTimeStamp>\d*?) (?<authorTimeZone>.*?)\s*committer (?<committerName>.*?) <(?<committerEmail>.*?)> (?<committerTimeStamp>\d*?) (?<committerTimeZone>.*)\s*(?:gpgsig (?:.|\s)*?-----END PGP SIGNATURE-----)?\s*(?<message>.*)\s*(?<description>(?:.|\s)*)/gm
+  log.debug("before match")
+  const match = commitRegex.exec(rawContent)
+  log.debug("after match: " + JSON.stringify(match))
+  const groups = match?.groups ?? {}
+
+  const tree = groups["tree"]
+  const parent = groups["parent"] ?? emptyGitCommitHash
+  const parent2 = groups["parent2"] ?? null
+  const author = {
+    name: groups["authorName"],
+    email: groups["authorEmail"],
+    timestamp: Number(groups["authorTimeStamp"]),
+    timezone: groups["authorTimeZone"],
+  }
+  const committer = {
+    name: groups["committerName"],
+    email: groups["committerEmail"],
+    timestamp: Number(groups["committerTimeStamp"]),
+    timezone: groups["committerTimeZone"],
+  }
+  const message = groups["message"]
+  const description = groups["description"]
+  const coauthors = description ? getCoAuthors(description) : []
+
+  return {
+    type: "commit",
+    hash,
+    tree,
+    parent,
+    parent2,
+    author,
+    committer,
+    message,
+    description,
+    coauthors,
+  }
+}
+
+export async function analyzeCommit(repoName: string, hash: string): Promise<GitCommitObject> {
+  if (hash === undefined) {
+    throw Error("Hash is required")
+  }
+  const { tree, ...commit } = await analyzeCommitLight(hash)
+  const commitObject = {
+    ...commit,
+    tree: await analyzeTree(repoName, repoName, tree),
+  }
+  return commitObject
+}
+
+async function analyzeTree(path: string, name: string, hash: string): Promise<GitTreeObject> {
+  const rawContent = await GitCaller.getInstance().catFileCached(hash)
+  const entries = rawContent.split("\n").filter((x) => x.trim().length > 0)
+
+  const children: (GitTreeObject | GitBlobObject)[] = []
+  for await (const line of entries) {
+    const catFileRegex = /^.+?\s(?<type>\w+)\s(?<hash>.+?)\s+(?<name>.+?)\s*$/g
+    const groups = catFileRegex.exec(line)?.groups ?? {}
+
+    const type = groups["type"]
+    const hash = groups["hash"]
+    const name = groups["name"]
+
+    const newPath = [path, name].join("/")
+    log.debug(`Path: ${newPath}`)
+
+    switch (type) {
+      case "tree":
+        children.push(await analyzeTree(newPath, name, hash))
+        break
+      case "blob":
+        children.push({
+          type: "blob",
+          hash,
+          path: newPath,
+          name,
+          content: await GitCaller.getInstance().catFileCached(hash),
+          blameAuthors: await GitCaller.getInstance().parseBlame(newPath),
+        })
+        break
+      default:
+        throw new Error(` type ${type}`)
+    }
+  }
+
+  return {
+    type: "tree",
+    path,
+    name,
+    hash,
+    children,
+  }
+}
+
+function getCommandLine() {
+  switch (process.platform) {
+    case "darwin":
+      return "open" // MacOS
+    case "win32":
+      return "start" // Windows
+    default:
+      return "xdg-open" // Linux
+  }
+}
+
+export function openFile(path: string) {
+  path = path.split("/").slice(1).join("/") ?? path.split("\\").slice(1).join("\\")
+  exec(`${getCommandLine()} ${resolve(repoDir, path)}`).stderr?.on("data", (e) => {
+    // TODO show error in UI
+    log.error(`Cannot open file ${resolve(repoDir, path)}: ${e}`)
+  })
+}
+
+export async function updateTruckConfig(repoDir: string, updaterFn: (tc: TruckUserConfig) => TruckUserConfig) {
+  const truckConfigPath = resolve(repoDir, "truckconfig.json")
+  let currentConfig: TruckUserConfig = {}
+  try {
+    const configFileContents = await fs.readFile(truckConfigPath, "utf-8")
+    if (configFileContents) currentConfig = JSON.parse(configFileContents)
+  } catch (e) {}
+  const updatedConfig = updaterFn(currentConfig)
+  await fs.writeFile(truckConfigPath, JSON.stringify(updatedConfig, null, 2))
+}
+
+export async function analyze(useCache = true) {
+  const args = await getArgs()
+  GitCaller.initInstance(args.path)
+
+  if (args?.log) {
+    setLogLevel(args.log as string)
+  }
+
+  repoDir = args.path
+  if (!isAbsolute(repoDir)) repoDir = resolve(process.cwd(), repoDir)
+
+  const branch = args.branch
+
+  const hiddenFiles = args.hiddenFiles
+
+  const start = performance.now()
+  const [branchHead, branchName] = await describeAsyncJob(
+    () => findBranchHead(repoDir, branch),
+    "Finding branch head",
+    "Found branch head",
+    "Error finding branch head"
+  )
+  const repoName = getRepoName(repoDir)
+
+  let data: AnalyzerData | null = null
+
+  const dataPath = getOutPathFromRepoAndBranch(repoName, branchName)
+  if (fsSync.existsSync(dataPath)) {
+    const path = getOutPathFromRepoAndBranch(repoName, branchName)
+    const cachedData = JSON.parse(await fs.readFile(path, "utf8")) as AnalyzerData
+
+    // Check if the current branchHead matches the hash of the analyzed commit from the cache
+    const branchHeadMatches = branchHead === cachedData.commit.hash
+
+    // Check if the data uses the most recent analyzer data interface
+    const dataVersionMatches = cachedData.interfaceVersion === AnalyzerDataInterfaceVersion
+
+    const cacheConditions = {
+      branchHeadMatches,
+      dataVersionMatches,
+      refresh: !useCache,
+    }
+
+    // Only return cached data if every criteria is met
+    if (Object.values(cacheConditions).every(Boolean)) {
+      data = {
+        ...cachedData,
+        hiddenFiles,
+      }
+    } else {
+      const reasons = Object.entries(cacheConditions)
+        .filter(([, value]) => !value)
+        .map(([key, value]) => `${key}: ${value}`)
+        .join(", ")
+      log.info(`Reanalyzing, since the following cache conditions were not met: ${reasons}`)
+    }
+  }
+
+  if (data === null) {
+    const quotePathDefaultValue = await getDefaultGitSettingValue(repoDir, "core.quotepath")
+    await setGitSetting(repoDir, "core.quotePath", "off")
+    const renamesDefaultValue = await getDefaultGitSettingValue(repoDir, "diff.renames")
+    await setGitSetting(repoDir, "diff.renames", "true")
+    const renameLimitDefaultValue = await getDefaultGitSettingValue(repoDir, "diff.renameLimit")
+    await setGitSetting(repoDir, "diff.renameLimit", "1000000")
+
+    const runDateEpoch = Date.now()
+    const repoTree = await describeAsyncJob(
+      () => analyzeCommit(repoName, branchHead),
+      "Analyzing commit tree",
+      "Commit tree analyzed",
+      "Error analyzing commit tree"
+    )
+
+    const hydratedRepoTree = await describeAsyncJob(
+      () => hydrateData(repoDir, repoTree),
+      "Hydrating commit tree",
+      "Commit tree hydrated",
+      "Error hydrating commit tree"
+    )
+
+    await resetGitSetting(repoDir, "core.quotepath", quotePathDefaultValue)
+    await resetGitSetting(repoDir, "diff.renames", renamesDefaultValue)
+    await resetGitSetting(repoDir, "diff.renameLimit", renameLimitDefaultValue)
+
+    const defaultOutPath = getOutPathFromRepoAndBranch(repoName, branchName)
+    let outPath = resolve((args.out as string) ?? defaultOutPath)
+    if (!isAbsolute(outPath)) outPath = resolve(process.cwd(), outPath)
+
+    let latestV: string | undefined
+
+    try {
+      latestV = await latestVersion(pkg.name)
+    } catch {}
+
+    const authorUnions = args.unionedAuthors as string[][]
+    data = {
+      cached: false,
+      hiddenFiles,
+      authors: getAuthorSet(),
+      repo: repoName,
+      branch: branchName,
+      commit: hydratedRepoTree,
+      authorUnions: authorUnions,
+      interfaceVersion: AnalyzerDataInterfaceVersion,
+      currentVersion: pkg.version,
+      latestVersion: latestV,
+      lastRunEpoch: runDateEpoch,
+    }
+
+    await describeAsyncJob(
+      () =>
+        writeRepoToFile(outPath, {
+          ...data,
+          cached: true,
+        } as AnalyzerData),
+      "Writing data to file",
+      `Wrote data to ${resolve(outPath)}`,
+      `Error writing data to file ${outPath}`
+    )
+  }
+
+  const truckignore = ignore().add(hiddenFiles)
+  data.commit.tree = applyIgnore(data.commit.tree, truckignore)
+  TreeCleanup(data.commit.tree)
+  initMetrics(data)
+  data.commit.tree = applyMetrics(data, data.commit.tree)
+
+  const stop = performance.now()
+
+  log.raw(`\nDone in ${formatMs(stop - start)}`)
+
+  return data
+}
+
+export function getOutPathFromRepoAndBranch(repoName: string, branchName: string) {
+  return resolve(__dirname, "..", ".temp", repoName, `${branchName}.json`)
+}

package/src/analyzer/hydrate.server.ts

@@ -1,186 +1,186 @@
-import { emptyGitCommitHash } from "./constants"
-import isBinaryPath from "is-binary-path"
-import { join } from "path"
-import { log } from "./log.server"
-import {
-  GitBlobObject,
-  GitCommitObject,
-  GitCommitObjectLight,
-  HydratedGitBlobObject,
-  HydratedGitCommitObject,
-  HydratedGitTreeObject,
-  Person,
-  PersonWithTime,
-} from "./model"
-import { analyzeCommitLight } from "./analyze.server"
-import { gitDiffNumStatAnalyzed, lookupFileInTree } from "./util"
-import { Queue } from "./queue"
-
-const renamedFiles = new Map<string, string>()
-
-const authors = new Set<string>()
-
-export async function hydrateData(repo: string, commit: GitCommitObject): Promise<HydratedGitCommitObject> {
-  const data = commit as HydratedGitCommitObject
-
-  initially_mut(data)
-
-  const { hash: first } = data
-
-  await bfs(first, repo, data)
-
-  finally_mut(data)
-
-  return data
-}
-
-export function getAuthorSet() {
-  return Array.from(authors)
-}
-
-function initially_mut(data: HydratedGitCommitObject) {
-  data.minNoCommits = Number.MAX_VALUE
-  data.maxNoCommits = Number.MIN_VALUE
-  data.oldestLatestChangeEpoch = Number.MAX_VALUE
-  data.newestLatestChangeEpoch = Number.MIN_VALUE
-
-  addAuthorsField_mut(data.tree)
-}
-
-function addAuthorsField_mut(tree: HydratedGitTreeObject) {
-  for (const child of tree.children) {
-    if (child.type === "blob") {
-      child.authors = {}
-    } else {
-      addAuthorsField_mut(child)
-    }
-  }
-}
-
-async function bfs(first: string, repo: string, data: HydratedGitCommitObject) {
-  const expandedHashes = new Set<string>()
-  const queue = new Queue<string>()
-
-  queue.enqueue(first)
-
-  while (!queue.isEmpty()) {
-    const currHash = queue.dequeue()
-
-    if (expandedHashes.has(currHash)) continue
-
-    expandedHashes.add(currHash)
-
-    // don't compare the empty commit to it's parent
-    if (currHash == emptyGitCommitHash) continue
-
-    const currCommit = await analyzeCommitLight(currHash)
-    authors.add((currCommit.author as Person).name)
-    for (const person of currCommit.coauthors) authors.add(person.name)
-
-    const parentsOfCurr = parents(currCommit)
-
-    for (const parentHash of parentsOfCurr) {
-      switch (parentsOfCurr.size) {
-        case 2: // curr is a merge commit
-          queue.enqueue(parentHash)
-          break
-        case 1: // curr is a linear commit
-          await diffAndUpdate_mut(data, currCommit, parentHash)
-          queue.enqueue(parentHash)
-          break
-        default:
-          // curr is the root commit
-          await diffAndUpdate_mut(data, currCommit, emptyGitCommitHash)
-          break
-      }
-    }
-  }
-}
-
-function parents(obj: GitCommitObject | GitCommitObjectLight): Set<string> {
-  const parents = new Set<string>()
-
-  if (obj.parent !== null) parents.add(obj.parent)
-  if (obj.parent2 !== null) parents.add(obj.parent2)
-
-  return parents
-}
-
-async function diffAndUpdate_mut(data: HydratedGitCommitObject, currCommit: GitCommitObjectLight, parentHash: string) {
-  const { author } = currCommit
-
-  const currHash = currCommit.hash
-
-  log.debug(`comparing [${currHash}] -> [${parentHash}]`)
-
-  const fileChanges = await gitDiffNumStatAnalyzed(parentHash, currHash, renamedFiles)
-
-  for (const fileChange of fileChanges) {
-    const { pos, neg, file } = fileChange
-
-    const blob = await lookupFileInTree(data.tree, file)
-
-    if (file === "dev/null") continue
-    if (blob) {
-      updateBlob_mut(blob, author, currCommit, pos, neg)
-    }
-  }
-}
-
-function isBinaryFile(blob: GitBlobObject) {
-  return isBinaryPath(join(blob.path, blob.name))
-}
-
-function updateBlob_mut(
-  blob: GitBlobObject,
-  author: PersonWithTime,
-  currCommit: GitCommitObjectLight,
-  pos: number,
-  neg: number
-) {
-  const noCommits = 1 + ((blob as HydratedGitBlobObject).noCommits ?? 0)
-
-  const isBinary = isBinaryFile(blob)
-
-  const hydratedBlob = {
-    ...blob,
-    authors: (blob as HydratedGitBlobObject).authors ?? {},
-    noLines: isBinary ? 0 : blob.content?.split("\n").length,
-    noCommits: noCommits,
-    isBinary: isBinary,
-  } as HydratedGitBlobObject
-
-  if (!isBinary) {
-    const current = hydratedBlob.authors?.[author.name] ?? 0
-
-    const newValue = current + pos + neg
-    if (newValue > 0) {
-      for (const coauthor of currCommit.coauthors) {
-        hydratedBlob.authors[coauthor.name] = newValue
-      }
-      hydratedBlob.authors[author.name] = newValue
-    }
-  }
-
-  if (!hydratedBlob.lastChangeEpoch) {
-    const epoch = currCommit.author.timestamp
-    hydratedBlob.lastChangeEpoch = epoch
-  }
-
-  Object.assign(blob, hydratedBlob)
-  log.debug(`Updated blob ${blob.name} from commit ${currCommit.hash}`)
-}
-
-function finally_mut(data: HydratedGitCommitObject) {
-  discardContentField_mut(data.tree)
-}
-
-function discardContentField_mut(tree: HydratedGitTreeObject) {
-  for (const child of tree.children) {
-    if (child.type === "blob") {
-      child.content = undefined
-    } else {
-      discardContentField_mut(child)
-    }
-  }
-}
+import { emptyGitCommitHash } from "./constants"
+import isBinaryPath from "is-binary-path"
+import { join } from "path"
+import { log } from "./log.server"
+import {
+  GitBlobObject,
+  GitCommitObject,
+  GitCommitObjectLight,
+  HydratedGitBlobObject,
+  HydratedGitCommitObject,
+  HydratedGitTreeObject,
+  Person,
+  PersonWithTime,
+} from "./model"
+import { analyzeCommitLight } from "./analyze.server"
+import { gitDiffNumStatAnalyzed, lookupFileInTree } from "./util"
+import { Queue } from "./queue"
+
+const renamedFiles = new Map<string, string>()
+
+const authors = new Set<string>()
+
+export async function hydrateData(repo: string, commit: GitCommitObject): Promise<HydratedGitCommitObject> {
+  const data = commit as HydratedGitCommitObject
+
+  initially_mut(data)
+
+  const { hash: first } = data
+
+  await bfs(first, repo, data)
+
+  finally_mut(data)
+
+  return data
+}
+
+export function getAuthorSet() {
+  return Array.from(authors)
+}
+
+function initially_mut(data: HydratedGitCommitObject) {
+  data.minNoCommits = Number.MAX_VALUE
+  data.maxNoCommits = Number.MIN_VALUE
+  data.oldestLatestChangeEpoch = Number.MAX_VALUE
+  data.newestLatestChangeEpoch = Number.MIN_VALUE
+
+  addAuthorsField_mut(data.tree)
+}
+
+function addAuthorsField_mut(tree: HydratedGitTreeObject) {
+  for (const child of tree.children) {
+    if (child.type === "blob") {
+      child.authors = {}
+    } else {
+      addAuthorsField_mut(child)
+    }
+  }
+}
+
+async function bfs(first: string, repo: string, data: HydratedGitCommitObject) {
+  const expandedHashes = new Set<string>()
+  const queue = new Queue<string>()
+
+  queue.enqueue(first)
+
+  while (!queue.isEmpty()) {
+    const currHash = queue.dequeue()
+
+    if (expandedHashes.has(currHash)) continue
+
+    expandedHashes.add(currHash)
+
+    // don't compare the empty commit to it's parent
+    if (currHash == emptyGitCommitHash) continue
+
+    const currCommit = await analyzeCommitLight(currHash)
+    authors.add((currCommit.author as Person).name)
+    for (const person of currCommit.coauthors) authors.add(person.name)
+
+    const parentsOfCurr = parents(currCommit)
+
+    for (const parentHash of parentsOfCurr) {
+      switch (parentsOfCurr.size) {
+        case 2: // curr is a merge commit
+          queue.enqueue(parentHash)
+          break
+        case 1: // curr is a linear commit
+          await diffAndUpdate_mut(data, currCommit, parentHash)
+          queue.enqueue(parentHash)
+          break
+        default:
+          // curr is the root commit
+          await diffAndUpdate_mut(data, currCommit, emptyGitCommitHash)
+          break
+      }
+    }
+  }
+}
+
+function parents(obj: GitCommitObject | GitCommitObjectLight): Set<string> {
+  const parents = new Set<string>()
+
+  if (obj.parent !== null) parents.add(obj.parent)
+  if (obj.parent2 !== null) parents.add(obj.parent2)
+
+  return parents
+}
+
+async function diffAndUpdate_mut(data: HydratedGitCommitObject, currCommit: GitCommitObjectLight, parentHash: string) {
+  const { author } = currCommit
+
+  const currHash = currCommit.hash
+
+  log.debug(`comparing aaaa [${currHash}] -> [${parentHash}]`)
+
+  const fileChanges = await gitDiffNumStatAnalyzed(parentHash, currHash, renamedFiles)
+
+  for (const fileChange of fileChanges) {
+    const { pos, neg, file } = fileChange
+
+    const blob = await lookupFileInTree(data.tree, file)
+
+    if (file === "dev/null") continue
+    if (blob) {
+      updateBlob_mut(blob, author, currCommit, pos, neg)
+    }
+  }
+}
+
+function isBinaryFile(blob: GitBlobObject) {
+  return isBinaryPath(join(blob.path, blob.name))
+}
+
+function updateBlob_mut(
+  blob: GitBlobObject,
+  author: PersonWithTime,
+  currCommit: GitCommitObjectLight,
+  pos: number,
+  neg: number
+) {
+  const noCommits = 1 + ((blob as HydratedGitBlobObject).noCommits ?? 0)
+
+  const isBinary = isBinaryFile(blob)
+
+  const hydratedBlob = {
+    ...blob,
+    authors: (blob as HydratedGitBlobObject).authors ?? {},
+    noLines: isBinary ? 0 : blob.content?.split("\n").length,
+    noCommits: noCommits,
+    isBinary: isBinary,
+  } as HydratedGitBlobObject
+
+  if (!isBinary) {
+    const current = hydratedBlob.authors?.[author.name] ?? 0
+
+    const newValue = current + pos + neg
+    if (newValue > 0) {
+      for (const coauthor of currCommit.coauthors) {
+        hydratedBlob.authors[coauthor.name] = newValue
+      }
+      hydratedBlob.authors[author.name] = newValue
+    }
+  }
+
+  if (!hydratedBlob.lastChangeEpoch) {
+    const epoch = currCommit.author.timestamp
+    hydratedBlob.lastChangeEpoch = epoch
+  }
+
+  Object.assign(blob, hydratedBlob)
+  log.debug(`Updated blob ${blob.name} from commit ${currCommit.hash}`)
+}
+
+function finally_mut(data: HydratedGitCommitObject) {
+  discardContentField_mut(data.tree)
+}
+
+function discardContentField_mut(tree: HydratedGitTreeObject) {
+  for (const child of tree.children) {
+    if (child.type === "blob") {
+      child.content = undefined
+    } else {
+      discardContentField_mut(child)
+    }
+  }
+}