@ridit/forge 0.2.6

package/src/utils/branch.ts

@@ -0,0 +1,590 @@
+import path from "path";
+import fs from "fs";
+import type { Branch } from "../types/branch";
+import type { Repo } from "../types/repo";
+import type { Commit } from "../types/commit";
+import { matchPaths } from "./forgeIgnore";
+import { createCheckpoint } from "./checkpoint";
+import type { FileBlob } from "../types/files";
+import { determineFileStatus } from "./add";
+import { commitInBranch, getCommit, getLatestCommitId } from "./commit";
+import { updateRepo } from "./repo";
+import type { Checkpoint } from "../types/checkpoint";
+import { switchEmitter } from "./switchEvents";
+import { checkoutCommit } from "./checkout";
+import { readObject, writeObject } from "./objects";
+
+function getBranchPaths(repo_path: string, branch_name?: string) {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const branchesFolder = path.join(forgeFolder, "branches");
+  const branchFolder = branch_name
+    ? path.join(branchesFolder, branch_name)
+    : undefined;
+  const branchDataFile = branchFolder
+    ? path.join(branchFolder, "branch.json")
+    : undefined;
+  return { forgeFolder, branchesFolder, branchFolder, branchDataFile };
+}
+
+export function createBranch(
+  repo_path: string,
+  branch_name: string,
+): { status: "ok" | "error"; error?: string } {
+  const { branchDataFile, branchFolder, branchesFolder } = getBranchPaths(
+    repo_path,
+    branch_name,
+  );
+  const branchCommitsFolder = path.join(branchFolder!, "commits");
+
+  if (!fs.existsSync(branchesFolder))
+    fs.mkdirSync(branchesFolder, { recursive: true });
+
+  try {
+    fs.mkdirSync(branchFolder!, { recursive: true });
+    fs.mkdirSync(branchCommitsFolder, { recursive: true });
+
+    fs.writeFileSync(
+      branchDataFile!,
+      JSON.stringify({ name: branch_name, latestCommitId: "" } as Branch),
+    );
+
+    const currentBranch = getCurrentBranch(repo_path);
+    if (currentBranch.error || !currentBranch.branch) {
+      commitInBranch("Initial commit", repo_path, branch_name);
+    } else {
+      const branch = currentBranch.branch;
+      const commitsFolder = path.join(
+        repo_path,
+        ".forge",
+        "branches",
+        branch.name,
+        "commits",
+      );
+      const newBranchCommitsFolder = path.join(
+        repo_path,
+        ".forge",
+        "branches",
+        branch_name,
+        "commits",
+      );
+
+      fs.cpSync(commitsFolder, newBranchCommitsFolder, { recursive: true });
+
+      fs.writeFileSync(
+        branchDataFile!,
+        JSON.stringify({
+          name: branch_name,
+          latestCommitId: branch.latestCommitId,
+        } as Branch),
+      );
+    }
+  } catch (err) {
+    return { status: "error", error: err as string };
+  }
+
+  return { status: "ok" };
+}
+
+export function getBranch(
+  repo_path: string,
+  branch_name: string,
+): { status: "ok" | "error"; branch?: Branch; error?: string } {
+  const { branchDataFile, branchFolder, branchesFolder } = getBranchPaths(
+    repo_path,
+    branch_name,
+  );
+
+  if (!fs.existsSync(branchesFolder))
+    return {
+      status: "error",
+      error: "branches folder is missing, consider reinitialize repo.",
+    };
+
+  if (!fs.existsSync(branchFolder!))
+    return {
+      status: "error",
+      error: `${branch_name} doesn't exists.`,
+    };
+
+  if (!fs.existsSync(branchDataFile!))
+    return {
+      status: "error",
+      error: `${branch_name} meta data is missing, consider reinitialize the branch.`,
+    };
+
+  const branchData = JSON.parse(fs.readFileSync(branchDataFile!, "utf-8"));
+
+  return { status: "ok", branch: branchData };
+}
+
+export function updateBranch(
+  repo_path: string,
+  branch_name: string,
+  latest_commit_id: string,
+): { status: "ok" | "error"; error?: string } {
+  const { branchDataFile, branchFolder, branchesFolder } = getBranchPaths(
+    repo_path,
+    branch_name,
+  );
+
+  if (!fs.existsSync(branchesFolder))
+    return {
+      status: "error",
+      error: "branches folder is missing, consider reinitialize repo.",
+    };
+
+  if (!fs.existsSync(branchFolder!))
+    return {
+      status: "error",
+      error: `${branch_name} doesn't exists.`,
+    };
+
+  if (!fs.existsSync(branchDataFile!))
+    return {
+      status: "error",
+      error: `${branch_name} meta data is missing, consider reinitialize the branch.`,
+    };
+
+  const branchData = JSON.parse(
+    fs.readFileSync(branchDataFile!, "utf-8"),
+  ) as Branch;
+  const newData = { ...branchData, latestCommitId: latest_commit_id } as Branch;
+
+  fs.writeFileSync(branchDataFile!, JSON.stringify(newData));
+
+  return { status: "ok" };
+}
+
+export function getCurrentBranch(repo_path: string): {
+  status: "ok" | "error";
+  branch?: Branch;
+  error?: string;
+} {
+  const { branchesFolder } = getBranchPaths(repo_path);
+  const forgeFolder = path.join(repo_path, ".forge");
+  const repoDataFile = path.join(forgeFolder, "repo.json");
+
+  if (!fs.existsSync(branchesFolder))
+    return {
+      status: "error",
+      error: "branches folder is missing, consider reinitialize repo.",
+    };
+
+  if (!fs.existsSync(repoDataFile))
+    return {
+      status: "error",
+      error: `repo meta data is missing, consider reinitialize the branch.`,
+    };
+
+  const branchName = (
+    JSON.parse(fs.readFileSync(repoDataFile, "utf-8")) as Repo
+  ).branch;
+
+  const branchFolder = path.join(branchesFolder, branchName);
+  const branchDataFile = path.join(branchFolder, "branch.json");
+
+  if (!fs.existsSync(branchFolder))
+    return {
+      status: "error",
+      error: `${branchName} doesn't exists, consider reinitializing the repo.`,
+    };
+
+  if (!fs.existsSync(branchDataFile))
+    return {
+      status: "error",
+      error: `${branchName} meta data is missing, consider reinitialize the branch.`,
+    };
+
+  const branchData = JSON.parse(
+    fs.readFileSync(branchDataFile, "utf-8"),
+  ) as Branch;
+
+  return { status: "ok", branch: branchData };
+}
+
+export function listBranches(repo_path: string): {
+  status: "ok" | "error";
+  branches?: Branch[];
+  error?: string;
+} {
+  const { branchesFolder } = getBranchPaths(repo_path);
+
+  if (!fs.existsSync(branchesFolder))
+    return {
+      status: "error",
+      error: "branches folder is missing, consider reinitialize repo.",
+    };
+
+  const files = fs.readdirSync(branchesFolder);
+  const branches = files.map((file) => {
+    const branch = JSON.parse(
+      fs.readFileSync(
+        path.join(branchesFolder, file.toString(), "branch.json"),
+        "utf-8",
+      ),
+    ) as Branch;
+    return branch;
+  });
+
+  return { status: "ok", branches };
+}
+
+function processFiles(basePath: string, files: (string | Buffer)[]) {
+  const normalized = files
+    .map((f) => path.join(basePath, f.toString()).replace(/\\/g, "/"))
+    .filter((p) => {
+      try {
+        return fs.statSync(p).isFile();
+      } catch {
+        return false;
+      }
+    });
+
+  const checkedFiles = matchPaths(normalized);
+
+  return checkedFiles;
+}
+
+export function switchBranch(
+  repo_path: string,
+  branch_name: string,
+): { status: "ok" | "error"; error?: string } {
+  const currentBranch = getCurrentBranch(repo_path);
+  if (currentBranch.error || !currentBranch.branch)
+    return { status: "error", error: "no current branch found" };
+
+  const list = fs.readdirSync(".", { recursive: true });
+  const files = processFiles(".", list);
+
+  const latestCommitId = getLatestCommitId(
+    repo_path,
+    currentBranch.branch.name,
+  );
+  if (latestCommitId.error)
+    return { status: "error", error: latestCommitId.error };
+
+  const fileBlobs = files.files?.map((f) => ({
+    name: path.basename(f),
+    path: f,
+    hash: writeObject(repo_path, fs.readFileSync(f).toString()),
+    status: determineFileStatus(repo_path, f).file_status ?? "untracked",
+  })) as FileBlob[];
+
+  const res = createCheckpoint(
+    repo_path,
+    fileBlobs,
+    currentBranch.branch.name,
+    latestCommitId.latestCommitId ?? "",
+  );
+  if (res.error) return { status: "error", error: res.error };
+  switchEmitter.emit("event", {
+    type: "checkpoint_created",
+    branch: currentBranch.branch.name,
+  });
+
+  files.files?.forEach((f) => fs.rmSync(f, { recursive: true }));
+  switchEmitter.emit("event", {
+    type: "files_deleted",
+    files: files.files ?? [],
+  });
+
+  const newBranch = getBranch(repo_path, branch_name);
+  if (newBranch.error || !newBranch.branch)
+    return {
+      status: "error",
+      error: newBranch.error || `${branch_name} not found`,
+    };
+
+  const latestCommit = newBranch.branch.latestCommitId
+    ? getCommit(repo_path, newBranch.branch.latestCommitId, branch_name)
+    : null;
+  if (latestCommit?.error)
+    return { status: "error", error: latestCommit.error };
+
+  const checkpointFile = path.join(
+    repo_path,
+    ".forge",
+    "branches",
+    branch_name,
+    "checkpoint.json",
+  );
+  const hasCheckpoint = fs.existsSync(checkpointFile);
+
+  if (hasCheckpoint) {
+    const checkpointData = JSON.parse(
+      fs.readFileSync(checkpointFile, "utf-8"),
+    ) as Checkpoint;
+    const targetLatestCommitId = getLatestCommitId(repo_path, branch_name);
+
+    const checkpointIsLatest =
+      targetLatestCommitId.latestCommitId === checkpointData.commitId ||
+      new Date(checkpointData.date) >=
+        new Date(latestCommit?.commit?.date ?? 0);
+
+    if (checkpointIsLatest) {
+      checkpointData.files.forEach((file) =>
+        fs.writeFileSync(file.path, readObject(repo_path, file.hash)),
+      );
+      switchEmitter.emit("event", {
+        type: "files_restored",
+        files: checkpointData.files.map((f) => f.path),
+        source: "checkpoint",
+      });
+    } else {
+      latestCommit?.commit?.fileBlobs.forEach((file) =>
+        fs.writeFileSync(file.path, readObject(repo_path, file.hash)),
+      );
+
+      switchEmitter.emit("event", {
+        type: "files_restored",
+        files: latestCommit?.commit?.fileBlobs.map((f) => f.path) ?? [],
+        source: "commit",
+      });
+    }
+  } else {
+    latestCommit?.commit?.fileBlobs.forEach((file) =>
+      fs.writeFileSync(file.path, readObject(repo_path, file.hash)),
+    );
+    switchEmitter.emit("event", {
+      type: "files_restored",
+      files: latestCommit?.commit?.fileBlobs.map((f) => f.path) ?? [],
+      source: "commit",
+    });
+  }
+
+  const res_2 = updateRepo(repo_path, { branch: branch_name });
+  if (res_2.error) return { status: "error", error: res_2.error };
+
+  switchEmitter.emit("event", {
+    type: "switched",
+    from: currentBranch.branch.name,
+    to: branch_name,
+  });
+
+  return { status: "ok" };
+}
+
+export function getCommitHistory(
+  repo_path: string,
+  branch_name: string,
+): string[] {
+  const commitIds: string[] = [];
+  const latestCommitId = getLatestCommitId(repo_path, branch_name);
+  if (!latestCommitId.latestCommitId) return commitIds;
+
+  let currentId: string | undefined = latestCommitId.latestCommitId;
+
+  while (currentId) {
+    commitIds.push(currentId);
+    const commit = getCommit(repo_path, currentId, branch_name);
+    currentId = commit.commit?.parent;
+  }
+
+  return commitIds;
+}
+
+export function mergeBranch(
+  current_branch: string,
+  target_branch: string,
+  repo_path: string,
+): { status: "ok" | "error"; error?: string } {
+  const currentBranchCommitHistory = getCommitHistory(
+    repo_path,
+    current_branch,
+  );
+  const targetBranchommitHistory = getCommitHistory(repo_path, target_branch);
+
+  let sharedCommit;
+
+  for (const cb of currentBranchCommitHistory) {
+    if (targetBranchommitHistory.includes(cb)) {
+      sharedCommit = cb;
+      break;
+    }
+  }
+
+  if (!sharedCommit)
+    return { status: "error", error: "no shared commit found." };
+
+  const latestCommitIdOfCurrentBranch = getLatestCommitId(
+    repo_path,
+    current_branch,
+  );
+  if (
+    latestCommitIdOfCurrentBranch.error ||
+    !latestCommitIdOfCurrentBranch.latestCommitId
+  )
+    return {
+      status: "error",
+      error: `no current latest commit in ${current_branch}`,
+    };
+
+  let conflict: boolean = false;
+  let targetChanged: FileBlob[] = [];
+
+  if (latestCommitIdOfCurrentBranch.latestCommitId === sharedCommit) {
+    conflict = false;
+  } else {
+    const latestCommitIdOfTargetBranch = getLatestCommitId(
+      repo_path,
+      target_branch,
+    );
+    if (
+      latestCommitIdOfTargetBranch.error ||
+      !latestCommitIdOfTargetBranch.latestCommitId
+    )
+      return {
+        status: "error",
+        error: `no current latest commit in ${target_branch}`,
+      };
+
+    const sharedCommitOfCurrentBranch = getCommit(
+      repo_path,
+      sharedCommit,
+      current_branch,
+    );
+    const latestCommitOfTargetBranch = getCommit(
+      repo_path,
+      latestCommitIdOfTargetBranch.latestCommitId,
+      target_branch,
+    );
+    const latestCommitOfCurrentBranch = getCommit(
+      repo_path,
+      latestCommitIdOfCurrentBranch.latestCommitId,
+      current_branch,
+    );
+
+    if (
+      sharedCommitOfCurrentBranch.error ||
+      !sharedCommitOfCurrentBranch.commit ||
+      latestCommitOfTargetBranch.error ||
+      !latestCommitOfTargetBranch.commit ||
+      latestCommitOfCurrentBranch.error ||
+      !latestCommitOfCurrentBranch.commit
+    )
+      return { status: "error", error: `` };
+
+    const currentChanged = latestCommitOfCurrentBranch.commit.fileBlobs.filter(
+      (f) =>
+        sharedCommitOfCurrentBranch.commit!.fileBlobs.find(
+          (s) => s.path === f.path,
+        )?.hash !== f.hash,
+    );
+
+    targetChanged = latestCommitOfTargetBranch.commit.fileBlobs.filter(
+      (f) =>
+        sharedCommitOfCurrentBranch.commit!.fileBlobs.find(
+          (s) => s.path === f.path,
+        )?.hash !== f.hash,
+    );
+
+    conflict = currentChanged.some((cf) =>
+      targetChanged.find((tf) => tf.path === cf.path),
+    );
+
+    if (conflict) {
+      const conflictFiles = currentChanged
+        .filter((cf) => targetChanged.find((tf) => tf.path === cf.path))
+        .map((f) => f.path);
+      switchEmitter.emit("event", {
+        type: "merge_conflict_detected",
+        files: conflictFiles,
+      });
+      return { status: "error", error: "conflict found." };
+    }
+  }
+
+  const targetBranchCommitFolder = path.join(
+    repo_path,
+    ".forge",
+    "branches",
+    target_branch,
+    "commits",
+  );
+  const currentBranchCommitFolder = path.join(
+    repo_path,
+    ".forge",
+    "branches",
+    current_branch,
+    "commits",
+  );
+
+  fs.cpSync(targetBranchCommitFolder, currentBranchCommitFolder, {
+    recursive: true,
+    force: true,
+  });
+
+  const latestCommitIdOfTargetBranch = getLatestCommitId(
+    repo_path,
+    target_branch,
+  );
+  if (
+    latestCommitIdOfTargetBranch.error ||
+    !latestCommitIdOfTargetBranch.latestCommitId
+  )
+    return {
+      status: "error",
+      error: `no latest commit found in ${target_branch}`,
+    };
+
+  updateBranch(
+    repo_path,
+    current_branch,
+    latestCommitIdOfTargetBranch.latestCommitId,
+  );
+
+  const latestCommitIdOfCurrentBranch2 = getLatestCommitId(
+    repo_path,
+    current_branch,
+  );
+  if (
+    latestCommitIdOfCurrentBranch2.error ||
+    !latestCommitIdOfCurrentBranch2.latestCommitId
+  )
+    return {
+      status: "error",
+      error: `no latest commit found in ${current_branch}`,
+    };
+
+  checkoutCommit(
+    latestCommitIdOfCurrentBranch2.latestCommitId,
+    repo_path,
+    current_branch,
+  );
+
+  switchEmitter.emit("event", {
+    type: "merge_complete",
+    from: target_branch,
+    to: current_branch,
+    filesChanged: targetChanged.length,
+  });
+
+  return { status: "ok" };
+}
+
+export function deleteBranch(
+  repo_path: string,
+  branch_name: string,
+): { status: "ok" | "error"; error?: string } {
+  const { branchFolder, branchesFolder } = getBranchPaths(
+    repo_path,
+    branch_name,
+  );
+
+  if (!fs.existsSync(branchesFolder))
+    return {
+      status: "error",
+      error: "branches folder is missing, consider reinitialize repo.",
+    };
+
+  if (!fs.existsSync(branchFolder!))
+    return { status: "error", error: `${branch_name} doesn't exists.` };
+
+  const currentBranch = getCurrentBranch(repo_path);
+  if (currentBranch.branch?.name === branch_name)
+    return { status: "error", error: `cannot delete current branch.` };
+
+  fs.rmSync(branchFolder!, { recursive: true, force: true });
+
+  return { status: "ok" };
+}

package/src/utils/checkout.ts

@@ -0,0 +1,57 @@
+import path from "path";
+import fs from "fs";
+import type { Commit } from "../types/commit";
+import { getCurrentBranch } from "./branch";
+import { readObject } from "./objects";
+
+export function checkoutCommit(
+  commitId: string,
+  repo_path: string,
+  branch_name?: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const currentBranch = getCurrentBranch(repo_path);
+  if (currentBranch.error || !currentBranch.branch) {
+    return {
+      status: "error",
+      error: currentBranch.error || "no current branch found.",
+    };
+  }
+  const branchName = branch_name ?? currentBranch.branch.name;
+  const commitFolder = path.join(
+    forgeFolder,
+    "branches",
+    branchName,
+    "commits",
+  );
+  const commitFile = path.join(commitFolder, `${commitId}.json`);
+
+  if (!fs.existsSync(commitFolder))
+    return {
+      status: "error",
+      error: "commits folder is missing, consider reinitialize repo.",
+    };
+
+  if (!fs.existsSync(commitFile))
+    return {
+      status: "error",
+      error: "commit not found.",
+    };
+
+  const commitData: Commit = JSON.parse(fs.readFileSync(commitFile, "utf-8"));
+  const files = commitData.fileBlobs;
+
+  console.log(
+    "restoring files:",
+    files.map((f) => f.path),
+  );
+
+  files.forEach((file) => {
+    fs.writeFileSync(file.path, readObject(repo_path, file.hash));
+  });
+
+  return { status: "ok" };
+}

package/src/utils/checkpoint.ts

@@ -0,0 +1,52 @@
+import path from "path";
+import fs from "fs";
+import type { Checkpoint } from "../types/checkpoint";
+import type { FileBlob } from "../types/files";
+
+export function createCheckpoint(
+  repo_path: string,
+  fileBlobs: FileBlob[],
+  branch_name: string,
+  commitId: string,
+): { status: "ok" | "error"; error?: string } {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const checkpointsFolder = path.join(forgeFolder, "branches", branch_name);
+  [];
+
+  if (!fs.existsSync(checkpointsFolder))
+    fs.mkdirSync(checkpointsFolder, { recursive: true });
+
+  const checkpointData = {
+    date: new Date().toISOString(),
+    files: fileBlobs,
+  } as Checkpoint;
+
+  const checkpointFile = path.join(checkpointsFolder, "checkpoint.json");
+  fs.writeFileSync(checkpointFile, JSON.stringify(checkpointData));
+
+  return { status: "ok" };
+}
+
+export function getCheckpoint(
+  repo_path: string,
+  branch_name: string,
+): { status: "ok" | "error"; checkpoint?: Checkpoint; error?: string } {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const checkpointsFolder = path.join(forgeFolder, "branches", branch_name);
+
+  if (!fs.existsSync(checkpointsFolder))
+    return {
+      status: "error",
+      error: "checkpoints folder is missing, consider reinitializing repo.",
+    };
+
+  const checkpointsFile = path.join(checkpointsFolder, "checkpoint.json");
+  if (!fs.existsSync(checkpointsFile))
+    return { status: "error", error: `checkpoint doesn't exists.` };
+
+  const checkpointData = JSON.parse(
+    fs.readFileSync(checkpointsFile, "utf-8"),
+  ) as Checkpoint;
+
+  return { status: "ok", checkpoint: checkpointData };
+}