Git Clone

// Index.GetAllChangedFiles(): compare the working directory with HEAD
// (headFiles = every file in the HEAD commit's tree)
foreach (var workingFile in workingFiles)
{
    if (headFiles.Contains(workingFile.Name))
    {
        // tracked in HEAD
        var fileNode = (FileNode)HEAD.CommitTree.Nodes[workingFile.Name];
        var currentContent = File.ReadAllText(
            WorkingDirectory.GetFullPathFromRepositoryPath(workingFile.RelativePath)
        );
        var d = diff.DiffText(fileNode.Content, currentContent);
        if (d.Length > 0)
            fileChanges[workingFile.Name] = FileChangeStatus.Modified;
    }
    else
    {
        fileChanges[workingFile.Name] = FileChangeStatus.Added;
    }

    // remove from headFiles so leftover = deleted
    headFiles.Remove(workingFile.Name);
}

// anything still in headFiles must have been deleted
foreach (var deleted in headFiles)
    fileChanges[deleted] = FileChangeStatus.Deleted;

Why it matters: every file in HEAD goes into a set and gets checked off as the working directory is scanned, so whatever is left over was deleted. Modified files are found by diffing the stored content against what's on disk.

// the tree is made of two node types behind one interface
public class NodeConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(INode).IsAssignableFrom(objectType);
    }

    public override object? ReadJson(JsonReader reader, Type objectType,
                                  object? existingValue, JsonSerializer serializer)
    {
        JObject obj = JObject.Load(reader);
        if (obj["Content"] != null)
        {
            return obj.ToObject<FileNode>(serializer);
        }
        else if (obj["Children"] != null)
        {
            return obj.ToObject<FolderNode>(serializer);
        }

        throw new JsonSerializationException("Unknown INode type.");
    }

    // WriteJson omitted
}

Why it matters: a folder's children can be files or folders, so JSON has to be told which one to rebuild. The converter looks for Content (a file) or Children (a folder).

# git <group> <command>   (every group also has "help")
git help

git repo create | edit | remove <file>
git repo list | status
git repo stage <file> | all

git commit <message>
git commit list

git branch create <name>
git branch delete | clone | checkout <id>
git branch list | current

Why it matters: command names live in constant structs (RepositoryCommands, CommitCommands, BranchCommands), shared by the parser and the help text, so a command is renamed in one place.