gitorial-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 gitorial-sdk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# cli
+
+The gitorial-cli is a CLI tool for helping manage and work with a Git repo following the [Gitorial format](https://github.com/gitorial-sdk).
+
+## Commands
+
+The following commands are available in this CLI:
+
+### unpack
+
+```sh
+yarn start unpack <gitorialPath> <gitorialBranch> <unpackedBranch>
+```
+
+The `unpack` command will take a branch in the Gitorial format, and unpack the steps of the gitorial into numbered folders in a separate branch.
+
+`unpackedBranch` can be an existing branch, and a new commit will be added on top of the existing history.
+
+A `gitorial_metadata.json` file will be created in each folder, allowing you to update the `commitMessage` for that step when the Gitorial is repacked.
+
+### repack
+
+```sh
+yarn start repack <gitorialPath> <unpackedBranch> <repackBranch>
+```
+
+The `repack` command will take a branch which is in the `unpacked` format (numbered folders with the content of each step), and create a fresh git commit history with those steps as commits in the Gitorial.
+
+`repackBranch` cannot be an existing branch name, as it risks deleting your Git history by mistake.
+
+The `gitorial_metadata.json` file will not be included in your repacked Gitorial.
+
+## Workflow
+
+The workflow for managing a gitorial is still in development, but assumes the following:
+
+- You have a Git repo with a branch in the Gitorial format.
+- You can `unpack` that branch into a branch named `unpacked`.
+    - You can keep this branch around forever, and always unpack into it. It can act as a history of changes to your Gitorial, since your raw Gitorial always resets its history.
+- You can then make changes to files in the `unpacked` branch. For example:
+    - Creating new step folders.
+	- Editing README or other documentation.
+	- Editing code.
+		- Although it is suggested to make code changes on the Gitorial branch, allowing you to use Git merge to ensure all changes are propagated through the tutorial.
+- You can commit changes or merge pull requests into the `unpacked` branch like normal.
+- When you are happy with the `unpacked` branch, you can `repack` it into a new branch `repacked`.
+- You can audit your changes in Git history (making sure step by step changes have a clean diff).
+- Finally, you can use `git reset repacked && git push --force` on your Gitorial branch to update your Gitorial.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "gitorial-cli",
+  "version": "0.1.0",
+  "description": "CLI Tools for Creating and Managing a Gitorial",
+  "main": "src/index.js",
+  "bin": "src/index.js",
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gitorial-sdk/cli.git"
+  },
+  "author": "Shawn Tabrizi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gitorial-sdk/cli/issues"
+  },
+  "homepage": "https://github.com/gitorial-sdk/cli#readme",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "simple-git": "^3.24.0"
+  }
+}

package/src/constants.js

@@ -0,0 +1,5 @@
+const GITORIAL_METADATA = "gitorial_metadata.json";
+const REPACK_BRANCH = "gitorial-repacked";
+const UNPACKED_BRANCH = "gitorial-unpacked";
+
+module.exports = { GITORIAL_METADATA, REPACK_BRANCH, UNPACKED_BRANCH };

package/src/index.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+
+program
+	.version('1.0.0')
+	.description('Node.js CLI application to manage Git repositories');
+
+// Command to unpack a Gitorial into another branch.
+program
+	.command('unpack')
+	.description('Unpack a Gitorial into another branch.')
+	.requiredOption('-p, --path <path>', 'The local path for the git repo containing the Gitorial.')
+	.requiredOption('-i, --inputBranch <inputBranch>', 'The branch in the repo with the Gitorial.')
+	.requiredOption('-o, --outputBranch <outputBranch>', 'The branch where you want to unpack the Gitorial.')
+	.option('-s, --subFolder <subFolder>', 'The subfolder (relative to the <path>) where you want the unpacked Gitorial to be placed.')
+	.action(({ path, inputBranch, outputBranch, subFolder }) => {
+		require('./unpack')(path, inputBranch, outputBranch, subFolder);
+	});
+
+
+// Command to create a repacked Gitorial from an unpacked Gitorial.
+program
+	.command('repack')
+	.description('Create a repacked Gitorial from an unpacked Gitorial. Must repack into a new branch.')
+	.requiredOption('-p, --path <path>', 'The local path for the git repo containing the Gitorial.')
+	.requiredOption('-i, --inputBranch <inputBranch>', 'The branch in the repo with the unpacked Gitorial.')
+	.requiredOption('-o, --outputBranch <outputBranch>', 'The branch where you want to repack the Gitorial. Branch must not exist.')
+	.option('-s, --subFolder <subFolder>', 'The subfolder (relative to the <path>) where you can find the unpacked Gitorial')
+	.action(({ path, inputBranch, outputBranch, subFolder }) => {
+		require('./repack')(path, inputBranch, outputBranch, subFolder);
+	});
+
+// Command to scaffold an mdBook source from a Gitorial.
+program
+	.command('mdbook')
+	.description('Scaffold the contents of a Gitorial in a new branch in the mdBook source format. You need to initialize an mdBook yourself ')
+	.requiredOption('-p, --path <path>', 'The local path for the git repo containing the Gitorial.')
+	.requiredOption('-i, --inputBranch <inputBranch>', 'The branch in the repo with the Gitorial.')
+	.requiredOption('-o, --outputBranch <outputBranch>', 'The branch where you want your mdBook to live')
+	.option('-s, --subFolder <subFolder>', 'The subfolder (relative to the <path>) where you want the mdBook source material to be placed.', 'src')
+	.action(({ path, inputBranch, outputBranch, subFolder }) => {
+		require('./mdbook')(path, inputBranch, outputBranch, subFolder);
+	});
+
+program.parse(process.argv);

package/src/mdbook.js

@@ -0,0 +1,453 @@
+const simpleGit = require("simple-git");
+const fs = require("fs");
+const os = require('os');
+const path = require("path");
+const { copyAllContentsAndReplace, copyFilesAndDirectories, doesBranchExist } = require("./utils");
+
+async function mdbook(repoPath, inputBranch, outputBranch, subFolder) {
+	try {
+		// Create a new temporary folder
+		const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitorial-source-'));
+		const mdbookDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitorial-mdbook-'));
+
+		// Clone the repo into the source folder.
+		const tempGit = simpleGit(sourceDir);
+
+		// Resolve the full path to the local repository
+		const resolvedRepoPath = path.resolve(repoPath);
+		await tempGit.clone(resolvedRepoPath, '.', ['--branch', inputBranch]);
+
+		await processGitorial(sourceDir, mdbookDir);
+
+		let sourceGit = simpleGit(repoPath);
+		// Check if the branch exists in the list of local branches
+		const branchExists = await doesBranchExist(sourceGit, outputBranch)
+
+		if (!branchExists) {
+			// Create a fresh branch if it does not exist.
+			await sourceGit.raw(['switch', '--orphan', outputBranch]);
+		} else {
+			// Checkout the current branch if it does.
+			await sourceGit.checkout(outputBranch);
+		}
+
+		let outputFolder = repoPath;
+		if (subFolder) {
+			outputFolder = path.join(outputFolder, subFolder);
+		}
+
+		copyAllContentsAndReplace(mdbookDir, outputFolder);
+
+		// Stage all files
+		await sourceGit.add('*');
+
+		// Create commit with commit message
+		await sourceGit.commit(`mdBook generated from ${inputBranch}`);
+
+		// Clean up source folder
+		fs.rmSync(sourceDir, { recursive: true });
+		fs.rmSync(mdbookDir, { recursive: true });
+		console.log("Temporary files removed.");
+
+		console.log("mdBook completed.");
+	} catch (error) {
+		console.error('Error:', error.message || error);
+	}
+}
+
+async function processGitorial(sourceDir, mdbookDir) {
+	const sourceGit = simpleGit(sourceDir);
+
+	// Retrieve commit log
+	const logs = await sourceGit.log();
+
+	let stepCounter = 0;
+	let templateFound = false;
+	let solutionFound = false;
+	let templateFiles = [];
+	let solutionFiles = [];
+	let sourceFiles = [];
+	let stepNames = [];
+
+	// Create a folder for each commit
+	// Reverse to make the oldest commit first
+	for ([index, log] of logs.all.reverse().entries()) {
+		const commitHash = log.hash;
+		const commitMessage = log.message;
+
+		const isReadme = commitMessage.toLowerCase().startsWith("readme: ");
+		const isTemplate = commitMessage.toLowerCase().startsWith("template: ");
+		const isSolution = commitMessage.toLowerCase().startsWith("solution: ");
+		const isSection = commitMessage.toLowerCase().startsWith("section: ");
+		const isAction = commitMessage.toLowerCase().startsWith("action: ");
+
+		let stepFolder = path.join(mdbookDir, stepCounter.toString());
+		if (!fs.existsSync(stepFolder)) {
+			fs.mkdirSync(stepFolder);
+		}
+
+		let sourceFolder = path.join(stepFolder, "source");
+		let templateFolder = path.join(stepFolder, "template");
+		let solutionFolder = path.join(stepFolder, "solution");
+
+		// Default assumption is output is not a template or solution
+		let outputFolder = sourceFolder;
+
+		if (isTemplate) {
+			// Check there isn't a template already in queue
+			if (templateFound) {
+				console.error("A second template was found before a solution.");
+				process.exit(1);
+			}
+
+			templateFound = true;
+
+			// make step folder
+			outputFolder = templateFolder;
+		}
+
+		if (isSolution) {
+			// Check that there is a template in queue
+			if (!templateFound) {
+				console.error("No template was found for this solution.");
+				process.exit(1);
+			}
+
+			// Check that a solution is not already found.
+			if (solutionFound) {
+				console.error("A second solution was found before a template.");
+				process.exit(1);
+			}
+
+			solutionFound = true;
+			outputFolder = solutionFolder;
+		}
+
+		fs.mkdirSync(outputFolder);
+
+		// Checkout the commit
+		console.log(`Checking out commit: ${commitHash}`);
+		await sourceGit.checkout(commitHash)
+
+		// Copy the contents to the commit folder
+		copyFilesAndDirectories(sourceDir, outputFolder);
+		console.log(`Contents of commit ${index} copied to ${outputFolder}`);
+
+		let previousCommit = "HEAD~1";
+		// This is the commit hash for an empty git project.
+		let emptyTree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+
+		if (index == 0) {
+			previousCommit = emptyTree;
+		}
+
+		// Get the list of modified or created files in the commit
+		const diffOutput = await sourceGit.diff(['--name-status', `${previousCommit}`, `HEAD`])
+		// Get the raw diff between the previous commit and HEAD, excluding README.md
+		const diffRaw = await sourceGit.diff([`${previousCommit}`, `HEAD`, ':(exclude)README.md']);
+
+		// Create a raw output
+		let diff_name = "changes.diff";
+		if (isSolution) {
+			diff_name = "solution.diff";
+		} else if (isTemplate) {
+			diff_name = "template.diff";
+		}
+		const diffFilePath = path.join(outputFolder, diff_name);
+		fs.writeFileSync(diffFilePath, diffRaw);
+
+		let fileStatus = diffOutput.split("\n").map((line) => {
+			const [status, file] = line.split("\t");
+			return { status, file };
+		});
+
+		if (isTemplate) {
+			templateFiles = fileStatus;
+		} else if (isSolution) {
+			solutionFiles = fileStatus;
+		} else {
+			sourceFiles = fileStatus;
+		}
+
+		// Reset sanity check and increment step
+		// Handle when both template and solution is found,
+		// or when there is a step that is neither a template or solution
+		if (
+			(templateFound && solutionFound) ||
+			(!templateFound && !solutionFound)
+		) {
+			if (isReadme) {
+				markdownContent = sectionMarkdown;
+			} else if (isSection) {
+				markdownContent = sectionMarkdown;
+				stepNames.push({
+					name: getStepName(sourceFolder),
+					is_section: true,
+				});
+			} else if (templateFound) {
+				markdownContent = templateMarkdown;
+				let templateFileText = generateFileMarkdown("template", templateFiles);
+				let solutionFileText = generateFileMarkdown("solution", solutionFiles);
+				markdownContent = markdownContent.replace(
+					"<!-- insert_template_files -->",
+					templateFileText
+				);
+				markdownContent = markdownContent.replace(
+					"<!-- insert_solution_files -->",
+					solutionFileText
+				);
+
+				let diffText = generateDiffMarkdown("template");
+				markdownContent = markdownContent.replace(
+					"<!-- insert_diff_files -->",
+					diffText
+				);
+
+				stepNames.push({
+					name: getStepName(templateFolder),
+					is_section: false,
+				});
+			} else {
+				markdownContent = sourceMarkdown;
+				let sourceFileText = generateFileMarkdown("source", sourceFiles);
+				markdownContent = markdownContent.replace(
+					"<!-- insert_source_files -->",
+					sourceFileText
+				);
+
+				let diffText = generateDiffMarkdown("source");
+				markdownContent = markdownContent.replace(
+					"<!-- insert_diff_files -->",
+					diffText
+				);
+
+				stepNames.push({
+					name: getStepName(sourceFolder),
+					is_section: false,
+				});
+			}
+			// Create a Markdown file in the commit folder
+			const markdownFilePath = path.join(stepFolder, "README.md");
+			fs.writeFileSync(markdownFilePath, markdownContent);
+			stepCounter += 1;
+			templateFound = false;
+			solutionFound = false;
+		}
+	}
+
+	generateSidebar(mdbookDir, stepNames);
+
+	console.log("Finished Parsing.");
+}
+
+// Generate the markdown text for files.
+function generateFileMarkdown(type, files) {
+	// type is expected to be one of "source", "solution", or "template"
+	if (type != "solution" && type != "source" && type != "template") {
+		process.exit(1);
+	}
+
+	let output = "";
+
+	let parsedFiles = [];
+	for (file of files) {
+		if (!file.file) {
+			continue;
+		}
+
+		let filepath = `./${type}/${file.file}`;
+		let filename = path.parse(filepath).base;
+
+		// Skip README
+		if (filename == "README.md") {
+			continue;
+		}
+		// Skip hidden files
+		if (filename.startsWith(".")) {
+			continue;
+		}
+		// Skip Cargo.lock
+		if (filename == "Cargo.lock") {
+			continue;
+		}
+
+		let classStyle = `file-${type}`;
+		if (file.status == "M") {
+			classStyle += " file-modified";
+		} else if (file.status == "A") {
+			classStyle += " file-added";
+		} else if (file.status == "D") {
+			classStyle += " file-deleted";
+		}
+
+		let codeStyle = "text";
+		let extname = path.extname(filepath);
+		if (extname == ".rs") {
+			codeStyle = "rust";
+		} else if (extname == ".toml") {
+			codeStyle = "toml";
+		}
+
+		parsedFiles.push({ filename: file.file, classStyle, codeStyle, filepath })
+	}
+
+	if (parsedFiles.length > 0) {
+		output += `<div class="tab">\n`;
+
+		for ([i, file] of parsedFiles.entries()) {
+			output += `<button class="subtab tablinks ${file.classStyle}${i == 0 ? " active" : ""}" onclick="switchSubTab(event, '${file.filename}')" data-id="${file.filename}">${file.filename}</button>\n`;
+		}
+
+		output += `</div>\n`
+
+		for ([i, file] of parsedFiles.entries()) {
+			output += `<div id="${type}/${file.filename}" class="subtab tabcontent${i == 0 ? " active" : ""}" data-id="${file.filename}">\n\n`;
+			output += `\`\`\`${file.codeStyle}\n{{#include ${file.filepath}}}\n\`\`\`\n\n`;
+			output += `</div>\n\n`;
+		}
+	} else {
+		output = "No files edited in this step.";
+	}
+
+	return output;
+}
+
+function generateDiffMarkdown(type) {
+	let output = "";
+
+	if (type == "template" || type == "solution") {
+		output += solutionDiffMarkdown;
+	} else {
+		output += changesDiffMarkdown;
+	}
+
+	return output;
+}
+
+let solutionDiffMarkdown = `
+<div class="tab">
+	<button class="difftab tablinks active" onclick="switchDiff(event, 'template.diff')" data-id="template.diff">template.diff</button>
+	<button class="difftab tablinks" onclick="switchDiff(event, 'solution.diff')" data-id="solution.diff">solution.diff</button>
+</div>
+<div id="template.diff" class="difftab tabcontent active" data-id="template.diff">
+
+\`\`\`diff\n{{#include ./template/template.diff}}\n\`\`\`
+
+</div>
+<div id="solution.diff" class="difftab tabcontent" data-id="solution.diff">
+
+\`\`\`diff\n{{#include ./solution/solution.diff}}\n\`\`\`
+
+</div>`;
+
+let changesDiffMarkdown = `
+<div class="tab">
+	<button class="difftab tablinks active" onclick="switchDiff(event, 'changes.diff')" data-id="changes.diff">changes.diff</button>
+</div>
+<div id="changes.diff" class="difftab tabcontent active" data-id="changes.diff">
+
+\`\`\`diff\n{{#include ./source/changes.diff}}\n\`\`\`
+
+</div>`;
+
+let templateMarkdown = `
+<div class="content-row">
+<div class="content-col">
+
+{{#include ./template/README.md}}
+
+</div>
+
+<div class="content-col">
+
+<div class="tab">
+  <button class="maintab tablinks active" onclick="switchMainTab(event, 'Template')">Template</button>
+  <button class="maintab tablinks" onclick="switchMainTab(event, 'Solution')">Solution</button>
+  <button class="maintab tablinks" onclick="switchMainTab(event, 'Diff')">Diff</button>
+</div>
+
+<div id="Template" class="maintab tabcontent active">
+
+<!-- insert_template_files -->
+
+</div>
+
+<div id="Solution" class="maintab tabcontent">
+
+<!-- insert_solution_files -->
+
+</div>
+
+<div id="Diff" class="maintab tabcontent">
+
+<!-- insert_diff_files -->
+
+</div>
+
+</div>
+</div>
+`;
+
+let sourceMarkdown = `
+<div class="content-row">
+<div class="content-col">
+
+{{#include ./source/README.md}}
+
+</div>
+<div class="content-col">
+
+<div class="tab">
+  <button class="maintab tablinks active" onclick="switchMainTab(event, 'Source')">Source</button>
+  <button class="maintab tablinks" onclick="switchMainTab(event, 'Diff')">Diff</button>
+</div>
+
+<div id="Source" class="maintab tabcontent active">
+
+<!-- insert_source_files -->
+
+</div>
+
+<div id="Diff" class="maintab tabcontent">
+
+<!-- insert_diff_files -->
+
+</div>
+
+</div>
+</div>
+`;
+
+let sectionMarkdown = `
+<div class="content-section">
+
+{{#include ./source/README.md}}
+
+</div>
+`;
+
+function getStepName(folder) {
+	const filePath = path.join(folder, "README.md");
+	const markdownContent = fs.readFileSync(filePath, "utf8");
+	const titleMatch = markdownContent.match(/^#\s+(.*)/m);
+	if (titleMatch) {
+		return titleMatch[1];
+	} else {
+		console.error(`Error getting markdown title.`);
+		process.exit(1);
+	}
+}
+
+function generateSidebar(mdbookDir, steps) {
+	const sidebarFilePath = path.join(mdbookDir, "SUMMARY.md");
+	let output = "";
+	steps.forEach(({ name, is_section }, index) => {
+		if (!is_section) {
+			output += `    `;
+		}
+		output += `- [${index}. ${name}](${index}/README.md)\n`;
+	});
+	fs.writeFileSync(sidebarFilePath, output);
+}
+
+module.exports = mdbook;

package/src/repack.js

@@ -0,0 +1,62 @@
+const simpleGit = require('simple-git');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { GITORIAL_METADATA } = require('./constants');
+const { copyAllContentsAndReplace } = require('./utils')
+
+async function repack(repoPath, inputBranch, outputBranch, subFolder) {
+	try {
+		const git = simpleGit(repoPath);
+		await git.raw(['switch', '--orphan', outputBranch]);
+
+		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitorial-repack-'));
+		await git.clone(repoPath, tempDir, ['--branch', inputBranch]);
+
+		let unpackedDir = tempDir;
+		if (subFolder) {
+			unpackedDir = path.join(unpackedDir, subFolder)
+		}
+
+		// Get list of steps
+		const steps = fs.readdirSync(unpackedDir)
+			.filter(item => fs.statSync(path.join(unpackedDir, item)).isDirectory())
+			.filter(item => item != '.git') // skip the git directory
+			.sort((a, b) => parseInt(a) - parseInt(b)); // Sort folders numerically
+
+		for (const step of steps) {
+			const stepFolderPath = path.join(unpackedDir, step);
+
+			// Read commit message from GITORIAL_METADATA
+			const commitInfoPath = path.join(stepFolderPath, GITORIAL_METADATA);
+			const commitInfo = JSON.parse(fs.readFileSync(commitInfoPath, 'utf-8'));
+			const commitMessage = commitInfo.commitMessage;
+
+			// Copy files from numbered folder to repo path
+			copyAllContentsAndReplace(stepFolderPath, repoPath);
+
+			// Stage all files
+			await git.add('*');
+
+			// Remove GITORIAL_METADATA
+			await git.reset(GITORIAL_METADATA);
+			await git.rm(GITORIAL_METADATA);
+
+			// Create commit with commit message
+			await git.commit(commitMessage);
+
+			console.log(`Commit created for step ${step} with message: ${commitMessage}`);
+		}
+
+		// Clean up temp folder
+		fs.rmSync(tempDir, { recursive: true });
+		console.log("Temporary files removed.");
+
+		console.log('Commits created successfully.')
+
+	} catch (error) {
+		console.error('Error:', error.message || error);
+	}
+}
+
+module.exports = repack;

package/src/unpack.js

@@ -0,0 +1,88 @@
+const simpleGit = require('simple-git');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { GITORIAL_METADATA } = require('./constants');
+const { copyAllContentsAndReplace, doesBranchExist, copyFilesAndDirectories } = require('./utils')
+
+async function unpack(repoPath, inputBranch, outputBranch, outputSubFolder) {
+	try {
+		// Create a new temporary folder
+		const sourceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitorial-source-'));
+		const unpackedDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gitorial-unpacked-'));
+
+		// Clone the repo into the source folder.
+		const tempGit = simpleGit(sourceDir);
+
+		// Resolve the full path to the local repository
+		const resolvedRepoPath = path.resolve(repoPath);
+		await tempGit.clone(resolvedRepoPath, '.', ['--branch', inputBranch]);
+
+		// Retrieve commit log
+		const logs = await tempGit.log();
+
+		// Create a folder for each commit
+		// Reverse to make the oldest commit first
+		for ([index, log] of logs.all.reverse().entries()) {
+			const commitHash = log.hash;
+			const commitMessage = log.message;
+
+			let stepFolder = path.join(unpackedDir, index.toString());
+
+			// Checkout the commit
+			console.log(`Checking out commit: ${commitHash}`);
+			await tempGit.checkout(commitHash);
+
+			// Copy the contents to the commit folder
+			copyFilesAndDirectories(sourceDir, stepFolder);
+			console.log(`Contents copied from ${sourceDir} to ${stepFolder}`);
+
+			// Create a JSON file in the commit folder
+			const jsonFilePath = path.join(stepFolder, GITORIAL_METADATA);
+			const commitInfoObject = {
+				"_Note": "This file will not be included in your final gitorial.",
+				commitMessage,
+			};
+
+			fs.writeFileSync(jsonFilePath, JSON.stringify(commitInfoObject, null, 2));
+		}
+
+		let sourceGit = simpleGit(repoPath);
+
+		// Check if the branch exists in the list of local branches
+		const branchExists = await doesBranchExist(sourceGit, outputBranch)
+
+		if (!branchExists) {
+			// Create a fresh branch if it does not exist.
+			await sourceGit.raw(['switch', '--orphan', outputBranch]);
+		} else {
+			// Checkout the current branch if it does.
+			await sourceGit.checkout(outputBranch)
+		}
+
+		let outputFolder = repoPath;
+		if (outputSubFolder) {
+			outputFolder = path.join(repoPath, outputSubFolder)
+		}
+
+		copyAllContentsAndReplace(unpackedDir, outputFolder);
+
+		// Stage all files
+		await sourceGit.add('*');
+
+		// Create commit with commit message
+		await sourceGit.commit(`Unpacked from ${inputBranch}`);
+
+		// Clean up source folder
+		fs.rmSync(sourceDir, { recursive: true });
+		fs.rmSync(unpackedDir, { recursive: true });
+		console.log("Temporary files removed.");
+
+		console.log("Process completed.");
+	} catch (error) {
+		console.error('Error:', error.message || error);
+	}
+
+}
+
+module.exports = unpack;

package/src/utils.js

@@ -0,0 +1,79 @@
+const fs = require('fs');
+const path = require('path');
+
+function copyAllContentsAndReplace(sourceDir, targetDir) {
+	// Create target directory if it doesn't exist
+	if (!fs.existsSync(targetDir)) {
+		fs.mkdirSync(targetDir, { recursive: true });
+	}
+
+	// Get list of items in source directory
+	const items = fs.readdirSync(sourceDir);
+
+	// Copy each item to target directory and replace existing items
+	items.forEach(item => {
+		const sourcePath = path.join(sourceDir, item);
+		const targetPath = path.join(targetDir, item);
+		if (fs.statSync(sourcePath).isDirectory()) {
+			if (fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory()) {
+				fs.rmSync(targetPath, { recursive: true }); // Remove existing directory
+			}
+			fs.mkdirSync(targetPath, { recursive: true }); // Create directory in target
+			copyAllContentsAndReplace(sourcePath, targetPath); // Recursively copy contents of directory
+		} else {
+			if (fs.existsSync(targetPath)) {
+				fs.unlinkSync(targetPath); // Delete existing file
+			}
+			fs.copyFileSync(sourcePath, targetPath); // Copy file
+		}
+	});
+}
+
+function copyFilesAndDirectories(source, target) {
+	// Check if source exists
+	if (!fs.existsSync(source)) {
+		console.error(`Source directory ${source} does not exist.`);
+		return;
+	}
+
+	// Create target directory if it doesn't exist
+	if (!fs.existsSync(target)) {
+		fs.mkdirSync(target, { recursive: true });
+	}
+
+	// Get list of items in source directory
+	const items = fs.readdirSync(source);
+
+	// Copy each item to target directory
+	items.forEach(item => {
+		// Skip .git folder
+		if (item === '.git') {
+			return;
+		}
+
+		const sourcePath = path.join(source, item);
+		const targetPath = path.join(target, item);
+		if (fs.statSync(sourcePath).isDirectory()) {
+			// Recursively copy directories
+			copyFilesAndDirectories(sourcePath, targetPath);
+		} else {
+			// Copy files
+			fs.copyFileSync(sourcePath, targetPath);
+		}
+	});
+}
+
+async function doesBranchExist(git, branchName) {
+	try {
+		// Get a list of all local branches
+		const branches = await git.branchLocal();
+		// Check if the branch exists in the list of local branches
+		const branchExists = branches.all.includes(branchName);
+		return branchExists;
+	} catch (error) {
+		console.error('Error checking if branch exists:', error);
+		return false;
+	}
+}
+
+module.exports = { copyAllContentsAndReplace, doesBranchExist, copyFilesAndDirectories };