This is what your team receives

class Repository {
  private commits: Map<string, Commit> = new Map();
  private branches: Map<string, string> = new Map();
  private HEAD: string = "main";

  init(): void {
    const rootCommit = this.createCommit("Initial commit", {}, null);
    this.branches.set("main", rootCommit.hash);
  }

  commit(message: string, changes: Record<string, string>): Commit {
    const parentHash = this.branches.get(this.HEAD)!;
    const parent = this.commits.get(parentHash)!;
    const newTree = { ...parent.tree, ...changes };
    const commit = this.createCommit(message, newTree, parentHash);
    this.branches.set(this.HEAD, commit.hash);
    return commit;
  }

  branch(name: string): void {
    const currentHash = this.branches.get(this.HEAD)!;
    this.branches.set(name, currentHash);
  }

  checkout(name: string): void {
    if (!this.branches.has(name)) throw new Error(`Branch ${name} not found`);
    this.HEAD = name;
  }

  log(limit = 10): Commit[] {
    const result: Commit[] = [];
    let hash: string | null = this.branches.get(this.HEAD) ?? null;
    while (hash && result.length < limit) {
      const commit = this.commits.get(hash)!;
      result.push(commit);
      hash = commit.parentHash;
    }
    return result;
  }

  private createCommit(
    message: string,
    tree: Record<string, string>,
    parentHash: string | null,
  ): Commit {
    const hash = this.computeHash(message, tree, parentHash);
    const commit: Commit = { hash, message, tree, parentHash, timestamp: new Date() };
    this.commits.set(hash, commit);
    return commit;
  }

  private computeHash(
    message: string,
    tree: Record<string, string>,
    parentHash: string | null,
  ): string {
    const content = JSON.stringify({ message, tree, parentHash });
    // Simplified hash – production would use SHA-256
    let h = 0;
    for (let i = 0; i < content.length; i++) {
      h = ((h << 5) - h + content.charCodeAt(i)) | 0;
    }
    return Math.abs(h).toString(16).padStart(8, "0");
  }
}