@ridit/forge 0.2.6

package/src/commands/status.tsx

@@ -0,0 +1,77 @@
+import { Box, Text } from "ink";
+import { ACCENT, BLUE, GREEN, PURPLE, RED, TEXT, YELLOW } from "../colors";
+import { useEffect, useState } from "react";
+import { listAllFilesWithStatus, type FileRef } from "../utils/status";
+import Spinner from "ink-spinner";
+import type { FileStatus } from "../types/files";
+
+export function StatusCommand() {
+  const [stage, setStage] = useState<"working" | "done">("working");
+  const [error, setError] = useState<string | null>(null);
+  const [files, setFiles] = useState<FileRef[]>([]);
+
+  useEffect(() => {
+    const res = listAllFilesWithStatus(".");
+
+    if (res.error) {
+      setError(res.error);
+      return;
+    }
+    if (!res.files) {
+      setError("no files found.");
+      return;
+    }
+
+    setFiles(res.files);
+
+    setStage("done");
+  }, []);
+
+  const colorMap: Record<FileStatus, string> = {
+    deleted: RED,
+    modified: YELLOW,
+    staged: BLUE,
+    untracked: PURPLE,
+    unchanged: TEXT,
+  };
+
+  if (error)
+    return (
+      <Box flexDirection="column">
+        <Text color={RED}>✗ {error}</Text>
+        <Text color={TEXT}>Retry</Text>
+      </Box>
+    );
+
+  return (
+    <>
+      {stage === "working" && (
+        <Box flexDirection="column">
+          <Box gap={1}>
+            <Text color={ACCENT}>
+              <Spinner type="balloon2" />
+            </Text>
+            <Text>Fetching status</Text>
+          </Box>
+        </Box>
+      )}
+      {stage === "done" && (
+        <Box flexDirection="column">
+          <Text color={GREEN}>✓ Status</Text>
+          {files.length > 0 ? (
+            files.map((file) => (
+              <Box key={file.path} flexDirection="column">
+                <Box gap={1}>
+                  <Text>{file.path}</Text>
+                  <Text color={colorMap[file.status]}>({file.status})</Text>
+                </Box>
+              </Box>
+            ))
+          ) : (
+            <Text color={TEXT}>No files changed</Text>
+          )}
+        </Box>
+      )}
+    </>
+  );
+}

package/src/index.tsx

@@ -0,0 +1,80 @@
+import { Command } from "commander";
+import { InitCommand } from "./commands/init";
+import { render } from "ink";
+import { AddCommand } from "./commands/add";
+import { CommitCommand } from "./commands/commit";
+import { CheckoutCommand } from "./commands/checkout";
+import { LogCommand } from "./commands/log";
+import { BranchCommand } from "./commands/branch";
+import { StatusCommand } from "./commands/status";
+
+const program = new Command();
+
+program
+  .command("init")
+  .description("init a repo")
+  .action(() => {
+    render(<InitCommand />);
+  });
+
+program
+  .command("add")
+  .argument("[path]")
+  .description("add a file or everything")
+  .action((path) => {
+    render(<AddCommand fileOrFolderPath={path} />);
+  });
+
+program
+  .command("commit")
+  .argument("[path]")
+  .requiredOption("-m, --message <msg>", "commit message")
+  .option("-a, --all", "commit all files")
+  .action((path, options) => {
+    render(
+      <CommitCommand
+        message={options.message}
+        isAll={options.all}
+        singlePath={path}
+      />,
+    );
+  });
+
+program
+  .command("checkout")
+  .argument("[commit]")
+  .option("-b, --branch <branch>", "specify which branch commit")
+  .action((commit, options) => {
+    render(<CheckoutCommand commitId={commit} branch={options.branch} />);
+  });
+
+program
+  .command("log")
+  .option("-g, --global", "log all commits")
+  .action((options) => {
+    render(<LogCommand global={options.global} />);
+  });
+
+program
+  .command("branch")
+  .argument("[name]")
+  .option("-d, --delete", "delete a branch")
+  .option("-s, --switch", "switch branches")
+  .option("-m, --merge <branch>", "merge branches")
+  .action((name, options) => {
+    render(
+      <BranchCommand
+        name={name}
+        isDelete={options.delete}
+        isSwitch={options.switch}
+        isMerge={!!options.merge}
+        mergingBranchName={options.merge}
+      />,
+    );
+  });
+
+program.command("status").action(() => {
+  render(<StatusCommand />);
+});
+
+program.parse(process.argv);

package/src/types/add.ts

@@ -0,0 +1,4 @@
+export interface File {
+  name: string;
+  content: string;
+}

package/src/types/branch.ts

@@ -0,0 +1,6 @@
+import type { Commit } from "./commit";
+
+export interface Branch {
+  name: string;
+  latestCommitId: string;
+}

package/src/types/checkpoint.ts

@@ -0,0 +1,7 @@
+import type { FileBlob } from "./files";
+
+export interface Checkpoint {
+  files: FileBlob[];
+  date: string;
+  commitId: string;
+}

package/src/types/commit.ts

@@ -0,0 +1,16 @@
+import type { FileBlob } from "./files";
+
+export interface Commit {
+  id: string;
+  message: string;
+  fileBlobs: FileBlob[];
+  date: string;
+  parent?: string;
+}
+
+export interface CommitRef {
+  id: string;
+  message: string;
+  branch: string;
+  date: string;
+}

package/src/types/files.ts

@@ -0,0 +1,13 @@
+export type FileStatus =
+  | "deleted"
+  | "untracked"
+  | "modified"
+  | "staged"
+  | "unchanged";
+
+export interface FileBlob {
+  name: string;
+  path: string;
+  hash: string;
+  status: FileStatus;
+}

package/src/types/repo.ts

@@ -0,0 +1,5 @@
+export interface Repo {
+  name: string;
+  isFork: boolean;
+  branch: string;
+}

package/src/utils/add.ts

@@ -0,0 +1,126 @@
+import path from "path";
+import fs from "fs";
+import type { FileBlob, FileStatus } from "../types/files";
+import { getCommit, getLatestCommitId } from "./commit";
+import { getCurrentBranch } from "./branch";
+import { hashContent, readObject, writeObject } from "./objects";
+
+export function addFile(
+  file_path: string,
+  repo_path: string,
+): {
+  status: "ok" | "error";
+  error?: string;
+} {
+  const forgeFolder = path.join(repo_path, ".forge");
+  const tempAddedFiles = path.join(forgeFolder, "tempAddedFiles.json");
+
+  if (!fs.existsSync(tempAddedFiles))
+    return {
+      status: "error",
+      error: "tempAddedFiles.json is missing, consider reinitialize repo.",
+    };
+
+  const parsed = JSON.parse(fs.readFileSync(tempAddedFiles, "utf-8"));
+
+  const tempFiles: FileBlob[] = Array.isArray(parsed.files) ? parsed.files : [];
+
+  const alreadyExists = tempFiles.some((f) => f.path === file_path);
+
+  if (alreadyExists) {
+    return { status: "ok" };
+  }
+
+  let fileStatus = determineFileStatus(repo_path, file_path);
+
+  const content = fs.readFileSync(file_path).toString();
+  const hash = writeObject(repo_path, content);
+
+  const newTempFiles = [
+    ...tempFiles,
+    {
+      name: path.basename(file_path),
+      path: file_path,
+      hash: hash,
+      status: fileStatus.file_status ?? "untracked",
+    } as FileBlob,
+  ];
+
+  fs.writeFileSync(
+    tempAddedFiles,
+    JSON.stringify({ files: newTempFiles }, null, 2),
+  );
+
+  return { status: "ok" };
+}
+
+export function determineFileStatus(
+  repo_path: string,
+  file_path: string,
+): { status: "ok" | "error"; file_status?: FileStatus; error?: string } {
+  const isInDisk = fs.existsSync(file_path);
+  if (!isInDisk) return { status: "ok", file_status: "deleted" };
+
+  const diskFileContent = fs.readFileSync(file_path).toString();
+
+  const forgeFolder = path.join(repo_path, ".forge");
+  const tempAddedFiles = path.join(forgeFolder, "tempAddedFiles.json");
+  const latestCommitId = getLatestCommitId(repo_path);
+  if (latestCommitId.error) {
+    return {
+      status: "error",
+      error: latestCommitId.error,
+    };
+  }
+
+  if (!latestCommitId.latestCommitId) {
+    return { status: "ok", file_status: "untracked" };
+  }
+
+  const branchName = getCurrentBranch(repo_path);
+  if (branchName.error || !branchName.branch) {
+    return {
+      status: "error",
+      error: latestCommitId.error || "found no branch",
+    };
+  }
+
+  const commitData = getCommit(
+    repo_path,
+    latestCommitId.latestCommitId,
+    branchName.branch.name,
+  );
+  if (commitData.error || !commitData.commit) {
+    return {
+      status: "error",
+      error: latestCommitId.error || "No commit data found.",
+    };
+  }
+
+  const parsed = JSON.parse(fs.readFileSync(tempAddedFiles, "utf-8"));
+
+  const tempFiles: FileBlob[] = Array.isArray(parsed.files) ? parsed.files : [];
+  const commitFiles: FileBlob[] = commitData.commit.fileBlobs;
+
+  const targetTempFile = tempFiles.find((t) => t.path === file_path);
+  const targetComittedFile = commitFiles.find((c) => c.path === file_path);
+
+  if (
+    targetComittedFile &&
+    isInDisk &&
+    readObject(repo_path, targetComittedFile.hash) !== diskFileContent
+  )
+    return { status: "ok", file_status: "modified" };
+  else if (
+    targetComittedFile &&
+    isInDisk &&
+    readObject(repo_path, targetComittedFile.hash) === diskFileContent
+  )
+    return { status: "ok", file_status: "unchanged" };
+  else if (!targetComittedFile && targetTempFile)
+    return { status: "ok", file_status: "staged" };
+  else if (!targetComittedFile && !targetTempFile)
+    return { status: "ok", file_status: "untracked" };
+
+  return { status: "ok" };
+}