codechronicle-cli 1.0.0

package/commands/init.js

@@ -0,0 +1,106 @@
+const fs = require("fs").promises; //file system: we can use asynchronous Promise-based operations like await fs.mkdir(...), await fs.writeFile(...)
+const path = require("path"); //helps safely construct filesystem paths
+const { getToken } = require("../utils/auth");
+const repositoryApi = require("../services/repositoryApi");
+const { requireAuth } = require("../utils/auth");
+
+async function initRepo(repoName) {
+  requireAuth();
+  // process.cwd() returns the directory from which the CLI command was executed.
+  const repoPath = path.resolve(process.cwd(), ".chron");
+
+  const commitsPath = path.join(repoPath, "commits");
+  const stagingPath = path.join(repoPath, "staging");
+  const configPath = path.join(repoPath, "config.json");
+
+  try {
+    // fs.access() checks whether .chron already exists to prevent reinitialization.
+    try {
+      await fs.access(repoPath);
+      console.log("Repository is already initialized.");
+      return;
+    } catch {
+      // Repository doesn't exist yet, so initialization can continue.
+    }
+
+    const token = getToken();
+
+    const response = await repositoryApi.createRepository(token, {
+      name: repoName,
+      description: "",
+      visibility: "public",
+    });
+
+    const repository = response.data;
+
+    // recursive:true also creates the parent .vcsGit directory automatically.
+    await fs.mkdir(commitsPath, { recursive: true });
+    await fs.mkdir(stagingPath, { recursive: true });
+
+    // information of the repository
+    const config = {
+      repositoryId: repository.repositoryId,
+      repositoryName: repository.repositoryName,
+      defaultBranch: "main",
+      lastPushedCommit: null,
+    };
+
+    // JSON.stringify(..., null, 2) converts the object to readable, indented JSON.
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+
+    console.log(`Repository '${repoName}' initialized successfully.`);
+  } catch (err) {
+    console.error("Error initializing repository:", err.message);
+  }
+}
+
+module.exports = { initRepo };
+
+/*
+============================================================
+WORKING OF INIT COMMAND
+============================================================
+
+The initRepo() function initializes a local Code Chronicle repository.
+
+When the user runs:
+    node index.js init <repoName>
+
+1. index.js uses Yargs to detect the "init" command and passes the
+   repository name to initRepo(repoName).
+
+2. process.cwd() identifies the directory where the user executed
+   the command. This directory is treated as the project root.
+
+3. A hidden ".vcsGit" directory is used to store all metadata related
+   to our custom version-control system.
+
+4. Before initialization, fs.access() checks whether ".vcsGit" already
+   exists. If it exists, initialization stops to avoid accidentally
+   overwriting an existing repository.
+
+5. Two directories are created inside ".vcsGit":
+
+      .vcsGit/
+      ├── commits/    -> Stores locally created commits.
+      └── staging/    -> Stores files added before they are committed.
+
+6. A config.json file is created to store repository configuration:
+
+      {
+        "storage": "supabase",
+        "bucket": "codechronicle",
+        "repoName": "<repository-name>"
+      }
+
+7. At this stage, everything exists only on the local system.
+   No files or repository data are uploaded to Supabase.
+
+8. Supabase will act as the remote storage and will be used later
+   when commands such as "push" and "pull" are executed.
+
+This is conceptually similar to "git init", where Git creates a
+.git directory to maintain repository metadata. In Code Chronicle,
+.vcsGit serves a similar purpose for our custom version-control system.
+============================================================
+*/

package/commands/login.js

@@ -0,0 +1,56 @@
+const inquirer = require("inquirer").default;
+const { login: loginUser } = require("../services/authService");
+const { saveConfig, getConfig } = require("../utils/chronConfig");
+const { getToken } = require("../utils/auth");
+
+async function login() {
+  const config = getConfig();
+  if (config) {
+    console.log(`✔ You are already logged in as ${config.user.username}.`);
+    console.log("Run 'chron logout' to login with another account.");
+    return;
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "email",
+      message: "Enter your email:",
+    },
+    {
+      type: "password",
+      name: "password",
+      message: "Enter your password:",
+      mask: "*",
+    },
+  ]);
+
+  console.log("\nLogging in...\n");
+
+  try {
+    const response = await loginUser(answers.email, answers.password);
+
+    saveConfig({
+      token: response.data.token,
+      user: response.data.user,
+    });
+
+    console.log(`✔ ${response.message}`);
+    console.log(`Welcome back, ${response.data.user.username}!`);
+  } catch (error) {
+    // Server is not reachable
+    if (error.code === "ECONNREFUSED") {
+      console.log("Backend server is not running.");
+      return;
+    }
+
+    // // No response received (network issue / timeout)
+    // if (!error.response) {
+    //   console.log("Unable to connect. Please check your internet connection.");
+    //   return;
+    // }
+    console.log(`✖ ${error.response?.data?.message || error.message}`);
+  }
+}
+
+module.exports = { login };

package/commands/logout.js

@@ -0,0 +1,12 @@
+const { getConfig, clearConfig } = require("../utils/chronConfig");
+const { requireAuth } = require("../utils/auth");
+
+async function logout() {
+  const config = requireAuth();
+  clearConfig();
+
+  console.log("✔ Logged out successfully.");
+  console.log(`Goodbye, ${config.user.username}!`);
+}
+
+module.exports = { logout };

package/commands/pull.js

@@ -0,0 +1,94 @@
+const fs = require("fs").promises; //file system
+const fswp = require("fs");
+const path = require("path");
+const supabase = require("../config/supabase");
+const { requireAuth } = require("../utils/auth");
+const repositoryApi = require("../services/repositoryApi");
+const { getToken } = require("../utils/auth");
+const { unzipDirectory } = require("../utils/unzipDirectory");
+
+async function pullRepo() {
+  let tempDirectory = null;
+  try {
+    requireAuth(); //checks user logged in or not
+    console.log("pulling commits back...");
+    const repoPath = path.resolve(process.cwd(), ".chron"); //gives the current directory path
+    const configPath = path.join(repoPath, "config.json"); //path to json
+
+    if (!fswp.existsSync(repoPath)) {
+      console.log("Repository not initialized.");
+      return;
+    }
+
+    const config = JSON.parse(await fs.readFile(configPath, "utf8")); //reads the json file
+    const { repositoryId } = config; //storing repoId
+
+    if (!repositoryId) {
+      console.log("Repository id not found.");
+      return;
+    }
+
+    const token = getToken(); //get the token
+    const latestCommitResponse = await repositoryApi.getLatestCommit(
+      repositoryId,
+      token
+    );
+    const latestCommit = latestCommitResponse.data.response;
+    console.log("Remote latest commit:", latestCommit);
+
+    const response = await repositoryApi.pullRepository(repositoryId, token); //receive the zip file from backend
+    // console.log(response);
+    const tempDir = path.join(repoPath, "temp"); //create temporary folder
+    tempDirectory = tempDir;
+    fswp.mkdirSync(tempDir, { recursive: true });
+    const zipPath = path.join(tempDir, "pull.zip");
+
+    const writer = fswp.createWriteStream(zipPath);
+    response.data.pipe(writer);
+
+    await new Promise((resolve, reject) => {
+      writer.on("finish", resolve);
+      writer.on("error", reject);
+    });
+
+    // console.log("ZIP downloaded successfully.");
+    const commitsPath = path.join(repoPath, "commits");
+
+    await unzipDirectory(zipPath, commitsPath);
+
+    // Update local config only after pull succeeds
+    config.lastCommit = latestCommit;
+    config.lastPushedCommit = latestCommit;
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+
+    console.log("done");
+  } catch (err) {
+    if (err.code === "ECONNREFUSED") {
+      console.log("Backend server is not running.");
+      return;
+    }
+    if (!err.response) {
+      console.log("Unable to connect. Please check your internet connection.");
+      return;
+    }
+
+    console.log("Pull failed");
+    console.log("Status:", err.response.status);
+    console.log("Backend response:", err.response.data);
+  } finally {
+    //deleting the temp folder
+    try {
+      if (tempDirectory && fswp.existsSync(tempDirectory)) {
+        fswp.rmSync(tempDirectory, {
+          recursive: true,
+          force: true,
+        });
+      }
+    } catch (err) {
+      console.log(err.code);
+    }
+  }
+}
+
+module.exports = { pullRepo };

package/commands/push.js

@@ -0,0 +1,70 @@
+const fs = require("fs").promises;
+const path = require("path");
+const { zipDirectory } = require("../utils/zipDirectory");
+const repositoryApi = require("../services/repositoryApi");
+const { getToken } = require("../utils/auth");
+const { requireAuth } = require("../utils/auth");
+
+async function pushRepo() {
+  requireAuth();
+  const repoPath = path.resolve(process.cwd(), ".chron");
+  const commitsPath = path.join(repoPath, "commits");
+  const configPath = path.join(repoPath, "config.json");
+
+  try {
+    try {
+      await fs.access(repoPath); // .chron exists
+    } catch {
+      console.log("Repository not initialized.");
+      return;
+    }
+    const config = JSON.parse(await fs.readFile(configPath, "utf8"));
+    const { repositoryId, lastCommit, lastPushedCommit } = config;
+
+    if (!lastCommit) {
+      console.log("No commits found. Commit your changes before pushing.");
+      return;
+    }
+
+    if (lastCommit === lastPushedCommit) {
+      console.log("Everything is up to date.");
+      return;
+    }
+
+    const zipPath = path.join(commitsPath, `${lastCommit}.zip`);
+    const commitPath = path.join(commitsPath, lastCommit);
+
+    await fs.access(commitPath);
+    await zipDirectory(commitPath, zipPath);
+
+    const token = getToken();
+
+    const response = await repositoryApi.pushRepository(
+      repositoryId,
+      zipPath,
+      token
+    );
+
+    console.log(response);
+
+    config.lastPushedCommit = lastCommit;
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+  } catch (err) {
+    if (err.code === "ECONNREFUSED") {
+      console.log("Backend server is not running.");
+      return;
+    }
+
+    if (!err.response) {
+      console.log("Unable to connect. Please check your internet connection.");
+      return;
+    }
+
+    console.log(
+      "problem in pushing...",
+      err.response?.data?.message || err.message
+    );
+  }
+}
+
+module.exports = { pushRepo };

package/commands/revert.js

@@ -0,0 +1,121 @@
+const fs = require("fs"); //file system
+const fsp = require("fs").promises;
+const path = require("path");
+const { requireAuth } = require("../utils/auth");
+
+async function revertRepo(commitID) {
+  requireAuth();
+  const repoPath = path.join(process.cwd(), ".chron"); //current working directory
+  const commitPath = path.join(repoPath, "commits", commitID); //path to the commit folder
+
+  try {
+    try {
+      await fsp.access(repoPath);
+      // .chron exists
+    } catch {
+      console.log("Repository not initialized.");
+      return;
+    }
+
+    // Check whether the commit exists
+    if (!fs.existsSync(commitPath)) {
+      console.log("Commit not found.");
+      return;
+    }
+
+    clearProjectRoot(process.cwd());
+
+    const commitItems = fs.readdirSync(commitPath); //read the particular commit folder
+    for (const item of commitItems) {
+      if (item === "commit.json") {
+        // Skip metadata file
+        continue;
+      }
+
+      const sourcePath = path.join(commitPath, item);
+      const destinationPath = path.join(process.cwd(), item);
+      const stats = fs.statSync(sourcePath);
+
+      if (stats.isFile()) {
+        // Restore file
+        fs.copyFileSync(sourcePath, destinationPath);
+        console.log(`Restored file: ${item}`);
+      } else if (stats.isDirectory()) {
+        if (fs.existsSync(destinationPath)) {
+          // Restore folder
+          fs.rmSync(destinationPath, {
+            recursive: true,
+            force: true,
+          });
+        }
+
+        copyDirectory(sourcePath, destinationPath);
+        console.log(`Restored folder: ${item}`);
+
+        const commitData = JSON.parse(
+          fs.readFileSync(path.join(commitPath, "commit.json"), "utf8")
+        );
+        const config = JSON.parse(
+          fs.readFileSync(path.join(repoPath, "config.json"), "utf8")
+        );
+        config.lastCommit = commitData.id;
+
+        fs.writeFileSync(
+          path.join(repoPath, "config.json"),
+          JSON.stringify(config, null, 2)
+        );
+      }
+    }
+    console.log("\nRepository reverted successfully.");
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+function clearProjectRoot(projectPath) {
+  const entries = fs.readdirSync(projectPath, {
+    withFileTypes: true,
+  });
+
+  for (const entry of entries) {
+    // Never delete the .chron directory
+    if (entry.name === ".chron") {
+      continue;
+    }
+
+    const fullPath = path.join(projectPath, entry.name);
+
+    fs.rmSync(fullPath, {
+      recursive: true,
+      force: true,
+    });
+
+    console.log(`Deleted: ${entry.name}`);
+  }
+}
+
+function copyDirectory(source, destination) {
+  if (!fs.existsSync(destination)) {
+    fs.mkdirSync(destination, { recursive: true });
+  }
+
+  const items = fs.readdirSync(source);
+
+  for (const item of items) {
+    if (item === "commit.json") {
+      continue;
+    }
+    const sourcePath = path.join(source, item);
+    const destinationPath = path.join(destination, item);
+
+    const stats = fs.statSync(sourcePath);
+
+    if (stats.isDirectory()) {
+      copyDirectory(sourcePath, destinationPath);
+    } else {
+      fs.copyFileSync(sourcePath, destinationPath);
+    }
+  }
+}
+
+module.exports = { revertRepo };

package/commands/whoami.js

@@ -0,0 +1,11 @@
+const { requireAuth } = require("../utils/auth");
+
+async function whoami() {
+  const config = requireAuth();
+  console.log("Logged in as\n");
+
+  console.log(`Username : ${config.user.username}`);
+  console.log(`Email    : ${config.user.email}`);
+}
+
+module.exports = { whoami };

package/config/config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  BACKEND_URL: "https://code-chronical-latest-backend.onrender.com",
+};

package/config/supabase.js

@@ -0,0 +1,24 @@
+const path = require("path");
+const { createClient } = require("@supabase/supabase-js");
+require("dotenv").config({
+  path: path.join(__dirname, "..", ".env"),
+  quiet : true
+});
+
+const supabase = createClient(
+  process.env.SUPABASE_URL,
+  process.env.SUPABASE_KEY
+);
+
+module.exports = supabase;
+
+/*
+---------------------------------------------------------
+Supabase Configuration
+---------------------------------------------------------
+This file initializes the Supabase client using the
+project URL and secret key stored in the .env file.
+The configured client is exported so it can be used
+throughout the application for Storage operations.
+---------------------------------------------------------
+*/

package/index.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+require("dotenv").config({
+  quiet: true,
+});
+
+//yargs
+const yargs = require("yargs");
+const { hideBin } = require("yargs/helpers");
+
+//commands
+const { login } = require("./commands/login");
+const { logout } = require("./commands/logout");
+const { whoami } = require("./commands/whoami");
+const { initRepo } = require("./commands/init");
+const { addRepo } = require("./commands/add");
+const { commitRepo } = require("./commands/commit");
+const { pushRepo } = require("./commands/push");
+const { pullRepo } = require("./commands/pull");
+const { revertRepo } = require("./commands/revert");
+const { cloneRepo } = require("./commands/clone");
+
+yargs(hideBin(process.argv))
+  .scriptName("chron") //change the name from index.js to chron
+  .usage("Usage: chron <command> [options]")
+
+  .example("chron login", "Login to your Code Chronicle account")
+  .example("chron init my-repo", "Initialize a new repository")
+  .example("chron add .", "Stage all files")
+  .example("chron push", "Push commits to remote")
+
+  .strict() //gives complete list of commands and verify the unknown commands
+
+  .command({
+    command: "login",
+    describe: "Login to Code Chronicle",
+    handler: login,
+  })
+  .command({
+    command: "logout",
+    describe: "Logout from Code Chronicle",
+    handler: logout,
+  })
+  .command({
+    command: "whoami",
+    describe: "check the current user detail",
+    handler: whoami,
+  })
+  .command(
+    "init <repoName>",
+    "Initialize a new repository",
+    (yargs) => {
+      yargs.positional("repoName", {
+        describe: "Repository name",
+        type: "string",
+      });
+    },
+    (argv) => {
+      initRepo(argv.repoName);
+    }
+  )
+  .command(
+    "add <file>",
+    "Add file to the repository",
+    (yargs) => {
+      yargs.positional("file", {
+        describe: "File to add to staging area",
+        type: "string",
+      });
+    },
+    (argv) => {
+      addRepo(argv.file);
+    }
+  )
+  .command(
+    "commit <message>",
+    "Commit the staged file",
+    (yargs) => {
+      yargs.positional("message", {
+        describe: "Commit message",
+        type: "string",
+      });
+    },
+    (argv) => {
+      commitRepo(argv.message);
+    }
+  )
+  .command(
+    "push",
+    "Push the latest commit to the remote repository",
+    {},
+    pushRepo
+  )
+  .command("pull", "pull the commits in to local machine", {}, pullRepo)
+  .command(
+    "revert <commitId>",
+    "Restore the project to a specific commit",
+    () => {},
+    (argv) => {
+      revertRepo(argv.commitId);
+    }
+  )
+  .command(
+    "clone <repoId>",
+    "Clone the Project",
+    () => {},
+    (argv) => {
+      cloneRepo(argv.repoId);
+    }
+  )
+  .help()
+  .parse();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "codechronicle-cli",
+  "version": "1.0.0",
+  "bin": {
+    "chron": "./index.js"
+  },
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.111.0",
+    "archiver": "^6.0.2",
+    "axios": "^1.18.1",
+    "dotenv": "^17.4.2",
+    "form-data": "^4.0.6",
+    "inquirer": "^14.0.2",
+    "unzipper": "^0.12.5",
+    "uuid": "^14.0.1",
+    "yargs": "^18.1.0"
+  }
+}

package/services/api.js

@@ -0,0 +1,11 @@
+const axios = require("axios");
+const config = require("../config/config");
+
+const api = axios.create({
+  baseURL: config.BACKEND_URL,
+  headers: {
+    "Content-Type": "application/json",
+  },
+});
+
+module.exports = api;

package/services/authService.js

@@ -0,0 +1,18 @@
+const api = require("./api");
+
+async function login(email, password) {
+  try {
+    const response = await api.post("/api/auth/login", {
+      email,
+      password,
+    });
+
+    return response.data;
+  } catch (error) {
+    throw error;
+  }
+}
+
+module.exports = {
+  login,
+};