@ridit/forge 0.2.6

package/src/utils/commit.ts

@@ -0,0 +1,237 @@
+import path from "path";
+import fs from "fs";
+import type { Commit, CommitRef } from "../types/commit";
+import type { FileBlob } from "../types/files";
+import { updateBranch } from "./branch";
+import type { Repo } from "../types/repo";
+import type { Branch } from "../types/branch";
+
+export function commitInGlobal(
+  message: string,
+  repo_path: string,
+  branch_name: string,
+  commitId: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const commitFolder = path.join(forgeFolder, "commits");
+
+  if (!fs.existsSync(commitFolder))
+    return {
+      status: "error",
+      error: "commits folder is missing, consider reinitialize repo.",
+    };
+
+  const newCommit: CommitRef = {
+    id: commitId,
+    message: message,
+    date: new Date().toISOString(),
+    branch: branch_name,
+  };
+
+  fs.writeFileSync(
+    path.join(commitFolder, `${commitId}.json`),
+    JSON.stringify(newCommit),
+  );
+
+  return { status: "ok" };
+}
+
+export function commitInBranch(
+  message: string,
+  repo_path: string,
+  branch_name: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const branchesFolder = path.join(forgeFolder, "branches");
+  const branchFolder = path.join(branchesFolder, branch_name);
+  const commitFolder = path.join(branchFolder, "commits");
+  const tempAddedFiles = path.join(forgeFolder, "tempAddedFiles.json");
+
+  if (!fs.existsSync(tempAddedFiles))
+    return {
+      status: "error",
+      error: "tempAddedFiles.json is missing, consider reinitialize repo.",
+    };
+
+  if (!fs.existsSync(commitFolder))
+    return {
+      status: "error",
+      error: "commits folder is missing, consider reinitialize repo.",
+    };
+
+  const parsed = JSON.parse(fs.readFileSync(tempAddedFiles, "utf-8"));
+
+  const tempFiles: FileBlob[] = Array.isArray(parsed.files) ? parsed.files : [];
+
+  const fileBlobs = tempFiles;
+
+  let parentCommit;
+
+  const latestCommitId = getLatestCommitId(repo_path, branch_name);
+  if (latestCommitId.error || !latestCommitId.latestCommitId) {
+  } else {
+    parentCommit = latestCommitId.latestCommitId;
+  }
+
+  const newCommitId = crypto.randomUUID();
+  const newCommit: Commit = {
+    id: newCommitId,
+    message: message,
+    fileBlobs,
+    date: new Date().toISOString(),
+    parent: parentCommit,
+  };
+
+  fs.writeFileSync(
+    path.join(commitFolder, `${newCommitId}.json`),
+    JSON.stringify(newCommit),
+  );
+
+  fs.writeFileSync(tempAddedFiles, JSON.stringify({ files: [] }));
+
+  const res = updateBranch(repo_path, branch_name, newCommitId);
+  if (res.error) return { status: "error", error: res.error };
+
+  commitInGlobal(message, repo_path, branch_name, newCommitId);
+
+  return { status: "ok" };
+}
+
+export function logCommits(repo_path: string): {
+  status: "ok" | "error";
+  error?: string;
+  commits?: CommitRef[];
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const commitFolder = path.join(forgeFolder, "commits");
+
+  if (!fs.existsSync(commitFolder))
+    return {
+      status: "error",
+      error: "commits folder is missing, consider reinitialize repo.",
+    };
+
+  const files = fs.readdirSync(commitFolder);
+  const commits = files.map((file) => {
+    const commit = JSON.parse(
+      fs.readFileSync(path.join(commitFolder, file.toString()), "utf-8"),
+    ) as CommitRef;
+    return commit;
+  });
+
+  return { status: "ok", commits };
+}
+
+export function logCommitsInBranch(
+  repo_path: string,
+  branch_name: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+  commits?: Commit[];
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const branchesFolder = path.join(forgeFolder, "branches");
+  const branchFolder = path.join(branchesFolder, branch_name);
+  const commitFolder = path.join(branchFolder, "commits");
+
+  if (!fs.existsSync(commitFolder))
+    return {
+      status: "error",
+      error: "commits folder is missing, consider reinitialize repo.",
+    };
+
+  const files = fs.readdirSync(commitFolder);
+  const commits = files.map((file) => {
+    const commit = JSON.parse(
+      fs.readFileSync(path.join(commitFolder, file.toString()), "utf-8"),
+    ) as Commit;
+    return commit;
+  });
+
+  return { status: "ok", commits };
+}
+
+export function getCommit(
+  repo_path: string,
+  commitId: string,
+  branch_name: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+  commit?: Commit;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const commitFolder = path.join(
+    forgeFolder,
+    "branches",
+    branch_name,
+    "commits",
+  );
+
+  if (!fs.existsSync(commitFolder))
+    return {
+      status: "error",
+      error: "commits folder is missing, consider reinitialize repo.",
+    };
+
+  const commitFile = path.join(commitFolder, `${commitId}.json`);
+
+  if (!fs.existsSync(commitFile))
+    return {
+      status: "error",
+      error: `${commitId} doesn't exists.`,
+    };
+
+  const commitData = JSON.parse(fs.readFileSync(commitFile, "utf-8")) as Commit;
+
+  return { status: "ok", commit: commitData };
+}
+
+export function getLatestCommitId(
+  repo_path: string,
+  branch_name?: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+  latestCommitId?: string;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const repoDataFile = path.join(forgeFolder, "repo.json");
+
+  if (!fs.existsSync(repoDataFile))
+    return {
+      status: "error",
+      error: `repo meta data is missing, consider reinitialize the branch.`,
+    };
+
+  const repoData = JSON.parse(fs.readFileSync(repoDataFile, "utf-8")) as Repo;
+  const branchName = branch_name ?? repoData.branch;
+  const branchFolder = path.join(forgeFolder, "branches", branchName);
+
+  if (!fs.existsSync(branchFolder))
+    return {
+      status: "error",
+      error: `${branchName} doesn't exists, consider reinitializing the repo.`,
+    };
+
+  const branchDataFile = path.join(branchFolder, "branch.json");
+
+  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", latestCommitId: branchData.latestCommitId };
+}

package/src/utils/forgeIgnore.ts

@@ -0,0 +1,56 @@
+import fs from "fs";
+import ignore from "ignore";
+import path from "path";
+
+const ig = ignore({ allowRelativePaths: true });
+
+export function matchPaths(files: string[]): {
+  status: "ok" | "error";
+  files?: string[];
+  error?: string;
+} {
+  let ignoreFile;
+
+  const forgeignoreFile = path.join(".", ".forgeignore");
+  const gitignoreFile = path.join(".", ".gitignore");
+
+  if (!fs.existsSync(forgeignoreFile)) ignoreFile = gitignoreFile;
+  else if (fs.existsSync(forgeignoreFile)) ignoreFile = forgeignoreFile;
+
+  if (ignoreFile && fs.existsSync(ignoreFile)) {
+    const content = fs.readFileSync(ignoreFile, "utf-8");
+    ig.add(content);
+  }
+
+  ig.add(".git");
+  ig.add(".forge");
+  ig.add("node_modules");
+
+  const checkedFiles: string[] = [];
+
+  files.forEach((file) => {
+    if (!ig.ignores(file)) checkedFiles.push(file);
+  });
+
+  return { status: "ok", files: checkedFiles };
+}
+
+export function createDefaultForgeIgnore(repo_path: string): {
+  status: "ok" | "error";
+  error?: string;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+
+  if (!fs.existsSync(forgeFolder))
+    return { status: "error", error: "repo doesn't exists" };
+
+  const forgeignoreFile = path.join(repo_path, ".forgeignore");
+
+  if (!fs.existsSync(forgeignoreFile))
+    fs.writeFileSync(
+      forgeignoreFile,
+      "node_modules\n.git\nout\ndist\n.forge\.next\.cache\nbuild\n__pycache__\n.env\.DS_Store",
+    );
+
+  return { status: "ok" };
+}

package/src/utils/objects.ts

@@ -0,0 +1,28 @@
+import crypto from "crypto";
+import path from "path";
+import fs from "fs";
+
+export function hashContent(content: string): string {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+export function writeObject(repo_path: string, content: string): string {
+  const hash = hashContent(content);
+  const folder = hash.slice(0, 2);
+  const file = hash.slice(2);
+
+  const objectDir = path.join(repo_path, ".forge", "objects", folder);
+  const objectPath = path.join(objectDir, file);
+
+  if (!fs.existsSync(objectDir)) fs.mkdirSync(objectDir, { recursive: true });
+  if (!fs.existsSync(objectPath)) fs.writeFileSync(objectPath, content);
+
+  return hash;
+}
+
+export function readObject(repo_path: string, hash: string): string {
+  const folder = hash.slice(0, 2);
+  const file = hash.slice(2);
+  const objectPath = path.join(repo_path, ".forge", "objects", folder, file);
+  return fs.readFileSync(objectPath, "utf-8");
+}

package/src/utils/repo.ts

@@ -0,0 +1,64 @@
+import path from "path";
+import fs from "fs";
+import type { Repo } from "../types/repo";
+import { createBranch } from "./branch";
+import { createDefaultForgeIgnore } from "./forgeIgnore";
+
+export function initRepo(folder_path: string): {
+  status: "ok" | "error";
+  error?: string;
+} {
+  const cwd = folder_path;
+  const forgeFolder = path.join(cwd, ".forge");
+  const repoInfoFile = path.join(forgeFolder, "repo.json");
+  const tempAddedFiles = path.join(forgeFolder, "tempAddedFiles.json");
+  const commitsFolder = path.join(forgeFolder, "commits");
+  const objectsFolder = path.join(forgeFolder, "objects");
+
+  if (fs.existsSync(forgeFolder)) {
+    return { status: "error", error: "Repo already exists" };
+  }
+
+  fs.mkdirSync(forgeFolder, { recursive: true });
+
+  fs.writeFileSync(
+    repoInfoFile,
+    JSON.stringify({
+      name: path.basename(folder_path),
+      isFork: false,
+      branch: "main",
+    } as Repo),
+  );
+
+  fs.writeFileSync(tempAddedFiles, JSON.stringify({ files: [] }));
+
+  fs.mkdirSync(commitsFolder, { recursive: true });
+  fs.mkdirSync(objectsFolder, { recursive: true });
+
+  const res = createBranch(".", "main");
+  if (res.error) return { status: "error", error: res.error };
+
+  const res_2 = createDefaultForgeIgnore(folder_path);
+  if (res_2.error) return { status: "error", error: res_2.error };
+
+  return { status: "ok" };
+}
+
+export function updateRepo(
+  repo_path: string,
+  data: Partial<Repo>,
+): { status: "ok" | "error"; error?: string } {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const repoInfoFile = path.join(forgeFolder, "repo.json");
+
+  if (!fs.existsSync(repoInfoFile))
+    return {
+      status: "error",
+      error: "repo.json is missing, consider reinitialize repo.",
+    };
+
+  const current = JSON.parse(fs.readFileSync(repoInfoFile, "utf-8")) as Repo;
+  fs.writeFileSync(repoInfoFile, JSON.stringify({ ...current, ...data }));
+
+  return { status: "ok" };
+}

package/src/utils/status.ts

@@ -0,0 +1,46 @@
+import { matchPaths } from "./forgeIgnore";
+import path from "path";
+import fs from "fs";
+import type { FileStatus } from "../types/files";
+import { checkPrime } from "crypto";
+import { determineFileStatus } from "./add";
+
+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 interface FileRef {
+  path: string;
+  status: FileStatus;
+}
+
+export function listAllFilesWithStatus(repo_path: string): {
+  status: "error" | "ok";
+  error?: string;
+  files?: FileRef[];
+} {
+  const list = fs.readdirSync(".", { recursive: true });
+  const checkedFiles = processFiles(".", list);
+
+  let files: { path: string; status: FileStatus }[] = [];
+
+  checkedFiles.files?.forEach((file) => {
+    const status =
+      determineFileStatus(repo_path, file).file_status ?? "unchanged";
+    files.push({ path: file, status });
+  });
+
+  return { status: "ok", files: files.filter((f) => f.status !== "unchanged") };
+}

package/src/utils/switchEvents.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events";
+export const switchEmitter = new EventEmitter();
+
+export type SwitchEvent =
+  | { type: "checkpoint_created"; branch: string }
+  | { type: "files_deleted"; files: string[] }
+  | { type: "files_restored"; files: string[]; source: "checkpoint" | "commit" }
+  | { type: "switched"; from: string; to: string }
+  | { type: "merge_conflict_detected"; files: string[] }
+  | { type: "merge_complete"; from: string; to: string; filesChanged: number };

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}