@cyberalien/git-utils 0.0.1 → 0.0.2

package/lib/git/clone.js

@@ -1,16 +1,11 @@
 import { execAsync } from "../misc/exec.js";
 import { doesGitRepoExist } from "./exists.js";
-import { rm } from "node:fs/promises";
+import { rmDir } from "../misc/rm.js";
 /**
 * Clone Git repository to target directory
 */
 async function cloneGitRepo(repo, target) {
-	try {
-		await rm(target, {
-			recursive: true,
-			force: true
-		});
-	} catch {}
+	await rmDir(target, false);
 	try {
 		await execAsync(`git clone ${repo.shallow ? "--depth 1" : ""} --branch ${repo.branch} ${repo.repo} ${target}`);
 	} catch {

package/lib/git/commit.js

@@ -3,12 +3,26 @@ import { getCurrentGitBranch } from "./branch.js";
 async function commitGitRepoChanges(target, message, push = true) {
 	try {
 		await execAsync(`git add -A`, { cwd: target });
-		await execAsync(`git commit -m "${message}"`, { cwd: target });
-		if (!(await execAsync(`git status`, { cwd: target })).stdout.includes("Your branch is ahead of")) {
-			console.error("Failed to commit changes");
+		const commitResult = await execAsync(`git commit -m "${message}"`, { cwd: target });
+		if (!commitResult.stdout.includes(message)) {
+			console.error("Failed to commit changes:", commitResult);
 			return false;
 		}
-		if (push) await execAsync(`git push origin "${await getCurrentGitBranch(target)}"`, { cwd: target });
+		if (!commitResult.stdout.includes("(root-commit)")) {
+			const statusResult = await execAsync(`git status`, { cwd: target });
+			if (!statusResult.stdout.includes("Your branch is ahead of")) {
+				if (statusResult.stdout.includes("nothing to commit, working tree clean")) {
+					console.error("Failed to commit changes: nothing to commit");
+					return false;
+				}
+				console.error("Failed to commit changes:", statusResult);
+				return false;
+			}
+		}
+		if (push) {
+			const pushResult = await execAsync(`git push origin "${await getCurrentGitBranch(target)}"`, { cwd: target });
+			console.log("pushResult:", pushResult.stdout);
+		}
 	} catch {
 		return false;
 	}

package/lib/git/exists.js

@@ -1,10 +1,11 @@
+import { join } from "node:path";
 import { lstat } from "node:fs/promises";
 /**
 * Check if Git repository exists in target directory
 */
 async function doesGitRepoExist(target) {
 	try {
-		return (await lstat(`${target}/.git`)).isDirectory();
+		return (await lstat(join(target, ".git"))).isDirectory();
 	} catch {
 		return false;
 	}

package/lib/git/index.d.ts

@@ -0,0 +1,12 @@
+import { GitRepoConfig } from "./types.js";
+interface CreateGitRepoResult {
+  packageJSON?: Record<string, unknown>;
+  bumpVersion?: string | ((currentVersion: string) => string);
+  files?: Record<string, string | Record<string, unknown>>;
+  commit?: string;
+}
+/**
+ * Create or update git repository
+ */
+declare function createGitRepo(repo: GitRepoConfig, target: string, callback: (isNew: boolean) => Promise<CreateGitRepoResult>, dryRun?: boolean): Promise<boolean>;
+export { CreateGitRepoResult, createGitRepo };

package/lib/git/index.js

@@ -0,0 +1,42 @@
+import { cloneGitRepo } from "./clone.js";
+import { commitGitRepoChanges } from "./commit.js";
+import { initGitRepo } from "./init.js";
+import { createFile } from "../misc/write.js";
+import { readJsonFile, writeJsonFile } from "../misc/json.js";
+import { updateVersionNumber } from "../misc/version.js";
+import { scanDirectory } from "../misc/scan.js";
+import { isGitRepoUpdated } from "./updated.js";
+import { join } from "node:path";
+import { rm } from "node:fs/promises";
+/**
+* Create or update git repository
+*/
+async function createGitRepo(repo, target, callback, dryRun = false) {
+	const cloneResult = await cloneGitRepo(repo, target);
+	if (!cloneResult) await initGitRepo(repo, target);
+	const oldFiles = await scanDirectory(target);
+	const filesToRemove = new Set(oldFiles.filter((file) => !file.startsWith(".git/")));
+	const result = await callback(!cloneResult);
+	if (result.packageJSON) {
+		if ("version" in result.packageJSON && oldFiles.includes("package.json")) try {
+			const oldFile = await readJsonFile(target, "package.json");
+			if (oldFile.version) {
+				const oldVersion = oldFile.version;
+				const newVersion = updateVersionNumber(oldVersion);
+				result.packageJSON.version = newVersion;
+				console.log("Bumped version number:", oldVersion, "->", newVersion, "of", result.packageJSON.name ?? "unknown");
+			}
+		} catch {}
+		await writeJsonFile(target, "package.json", result.packageJSON);
+		filesToRemove.delete("package.json");
+	}
+	if (result.files) for (const [name, content] of Object.entries(result.files)) {
+		if (typeof content === "string") await createFile(join(target, name), content);
+		else await writeJsonFile(target, name, content);
+		filesToRemove.delete(name);
+	}
+	for (const file of filesToRemove) await rm(join(target, file));
+	if (!await isGitRepoUpdated(target)) return true;
+	return await commitGitRepoChanges(target, result.commit ?? "chore: update files", !dryRun);
+}
+export { createGitRepo };

package/lib/git/init.d.ts

@@ -0,0 +1,6 @@
+import { GitRepoConfig } from "./types.js";
+/**
+ * Clone Git repository to target directory
+ */
+declare function initGitRepo(repo: GitRepoConfig, target: string): Promise<boolean>;
+export { initGitRepo };

package/lib/git/init.js

@@ -0,0 +1,30 @@
+import { execAsync } from "../misc/exec.js";
+import { doesGitRepoExist } from "./exists.js";
+import { rmDir } from "../misc/rm.js";
+/**
+* Clone Git repository to target directory
+*/
+async function initGitRepo(repo, target) {
+	await rmDir(target, true);
+	try {
+		const initResult = await execAsync(`git init`, { cwd: target });
+		if (!initResult.stdout.includes("Initialized empty Git repository")) {
+			console.error("Failed to init repo:", initResult);
+			return false;
+		}
+	} catch {
+		return false;
+	}
+	try {
+		await execAsync(`git remote add origin ${repo.repo}`, { cwd: target });
+	} catch {
+		return false;
+	}
+	try {
+		await execAsync(`git checkout -b "${repo.branch}"`, { cwd: target });
+	} catch {
+		return false;
+	}
+	return await doesGitRepoExist(target);
+}
+export { initGitRepo };

package/lib/git/updated.js

@@ -5,6 +5,5 @@ async function isGitRepoUpdated(target) {
 	} catch {
 		return null;
 	}
-	return false;
 }
 export { isGitRepoUpdated };

package/lib/misc/json.js

@@ -1,5 +1,6 @@
+import { createFile } from "./write.js";
 import { join } from "node:path";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 /**
 * Read and parse JSON file
 */
@@ -11,6 +12,6 @@ async function readJsonFile(target, filename) {
 * Write JSON file
 */
 async function writeJsonFile(target, filename, data) {
-	await writeFile(join(target, filename), JSON.stringify(data, null, 2) + "\n", "utf-8");
+	await createFile(join(target, filename), JSON.stringify(data, null, 2) + "\n");
 }
 export { readJsonFile, writeJsonFile };

package/lib/misc/rm.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Remove directory, create empty if needed
+ */
+declare function rmDir(target: string, createEmpty?: boolean): Promise<void>;
+export { rmDir };

package/lib/misc/rm.js

@@ -0,0 +1,14 @@
+import { mkdir, rm } from "node:fs/promises";
+/**
+* Remove directory, create empty if needed
+*/
+async function rmDir(target, createEmpty = false) {
+	try {
+		await rm(target, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	if (createEmpty) await mkdir(target, { recursive: true });
+}
+export { rmDir };

package/lib/misc/scan.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find all files in directory
+ */
+declare function scanDirectory(path: string): Promise<string[]>;
+export { scanDirectory };

package/lib/misc/scan.js

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import { lstat, readdir } from "node:fs/promises";
+/**
+* Find all files in directory
+*/
+async function scanDirectory(path) {
+	const results = [];
+	async function scan(subdir) {
+		const files = await readdir(join(path, subdir));
+		for (let i = 0; i < files.length; i++) {
+			const filename = join(subdir, files[i]);
+			let stat;
+			try {
+				stat = await lstat(join(path, filename));
+			} catch {
+				continue;
+			}
+			if (stat.isDirectory()) {
+				await scan(filename);
+				continue;
+			}
+			if (!stat.isFile()) continue;
+			results.push(filename);
+		}
+	}
+	await scan("");
+	return results;
+}
+export { scanDirectory };

package/lib/misc/version.d.ts

@@ -1,5 +1,9 @@
+/**
+ * Update version number using optional callback
+ */
+declare function updateVersionNumber(oldVersion: string, newVersion?: string | ((currentVersion: string) => string)): string;
 /**
  * Bump version in package.json file, return new version
  */
 declare function bumpPackageVersion(target: string, newVersion?: string | ((currentVersion: string) => string)): Promise<string>;
-export { bumpPackageVersion };
+export { bumpPackageVersion, updateVersionNumber };

package/lib/misc/version.js

@@ -1,5 +1,8 @@
 import { readJsonFile, writeJsonFile } from "./json.js";
-function update(oldVersion, newVersion) {
+/**
+* Update version number using optional callback
+*/
+function updateVersionNumber(oldVersion, newVersion) {
 	if (typeof newVersion === "string") return newVersion;
 	if (newVersion) return newVersion(oldVersion);
 	const parts = oldVersion.split(".");
@@ -14,11 +17,11 @@ function update(oldVersion, newVersion) {
 async function bumpPackageVersion(target, newVersion) {
 	const content = await readJsonFile(target, "package.json");
 	const oldVersion = content.version;
-	const version = update(oldVersion, newVersion);
+	const version = updateVersionNumber(oldVersion, newVersion);
 	if (version !== oldVersion) {
 		content.version = version;
 		writeJsonFile(target, "package.json", content);
 	}
 	return version;
 }
-export { bumpPackageVersion };
+export { bumpPackageVersion, updateVersionNumber };

package/lib/misc/write.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Create file, including creating directory if it doesn't exist
+ */
+declare function createFile(target: string, content: string): Promise<void>;
+export { createFile };

package/lib/misc/write.js

@@ -0,0 +1,13 @@
+import { dirname } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+/**
+* Create file, including creating directory if it doesn't exist
+*/
+async function createFile(target, content) {
+	const dir = dirname(target);
+	try {
+		await mkdir(dir, { recursive: true });
+	} catch {}
+	await writeFile(target, content, "utf8");
+}
+export { createFile };

package/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "description": "Functions for working with git repos.",
   "author": "Vjacheslav Trushkin",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "UNLICENSED",
   "bugs": "https://github.com/cyberalien/svg-utils/issues",
   "homepage": "https://cyberalien.dev/",