@hanseltime/template-repo-sync 1.0.1

package/lib/esm/formatting/infer-json-indent.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferJSONIndent = void 0;
+const spacingRegex = /[{[]\n?(?<spacing>\s+)["tf\d]/;
+function inferJSONIndent(rawJSON) {
+    const match = spacingRegex.exec(rawJSON);
+    if (!match?.groups?.spacing) {
+        // eslint-disable-next-line no-console
+        console.warn(`Could not find json indentation for json string: ${rawJSON.slice(40)} ... \nDefaulting to 4 spaces`);
+        // Four spaces
+        return "    ";
+    }
+    const spacing = match.groups.spacing;
+    // Handle the case where there were multiple newlines before a value
+    const lastNewLine = spacing.lastIndexOf("\n");
+    return match?.groups.spacing.slice(lastNewLine >= 0 ? lastNewLine + 1 : 0);
+}
+exports.inferJSONIndent = inferJSONIndent;

package/lib/esm/formatting/sync-results-to-md.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncResultsToMd = void 0;
+const template_sync_1 = require("../template-sync");
+function syncResultsToMd(result) {
+    return `# ${template_sync_1.TEMPLATE_SYNC_LOCAL_CONFIG} 
+
+## Stopped the following files from syncing:
+
+${result.localSkipFiles.reduce((s, file) => {
+        return `${s}* ${file}\n`;
+    }, "")}
+
+## Changed the following files from what they would have synced:
+
+${Object.keys(result.localFileChanges).reduce((s, file) => {
+        return `${s}${file}
+\`\`\`diff
+${result.localFileChanges[file].reduce((diffS, change) => {
+            return `${diffS}\n${makeChangeIntoDiffLines(change)}`;
+        }, "")}
+\`\`\``;
+    }, "")}
+`;
+}
+exports.syncResultsToMd = syncResultsToMd;
+function makeChangeIntoDiffLines(change, nonchangeMax = 3) {
+    const operator = change.added ? "+" : change.removed ? "-" : "";
+    if (!operator &&
+        nonchangeMax > 0 &&
+        change.count &&
+        change.count > nonchangeMax) {
+        const lines = change.value.split("\n");
+        const partial = lines.slice(lines.length - nonchangeMax);
+        return `...\n${partial.join("\n")}\n`;
+    }
+    return change.value.split("\n").reduce((s, line) => {
+        return `${s}${operator}${line}\n`;
+    }, "");
+}

package/lib/esm/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./template-sync"), exports);
+__exportStar(require("./formatting"), exports);

package/lib/esm/load-plugin.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugin = void 0;
+const plugins_1 = require("./plugins");
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function loadPlugin(mergeConfig, forExt, configDir) {
+    let handler;
+    if (mergeConfig.plugin) {
+        // First check if this is a loal .js file
+        const localPath = (0, path_1.resolve)(configDir, mergeConfig.plugin);
+        const importPath = (0, fs_1.existsSync)(localPath) ? localPath : mergeConfig.plugin;
+        try {
+            // Sad workaround for testing since dynamic import segfaults
+            if (process.env.JEST_WORKER_ID !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                handler = require(importPath);
+            }
+            else {
+                handler = (await import(importPath));
+            }
+            if (!handler.merge) {
+                handler = handler
+                    .default;
+            }
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    else {
+        if (!plugins_1.defaultExtensionMap[forExt]) {
+            throw new Error(`No default merge function supplied for ${forExt}.  Cannot have mere config without custom plugin supplied.`);
+        }
+        handler = plugins_1.defaultExtensionMap[forExt];
+    }
+    return handler;
+}
+exports.loadPlugin = loadPlugin;

package/lib/esm/match.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFilesInDir = exports.invertMatchPatterns = void 0;
+const fs_1 = require("fs");
+const micromatch_1 = require("micromatch");
+const path_1 = require("path");
+function invertMatchPatterns(patterns) {
+    return patterns.map((pattern) => {
+        if (pattern.startsWith("!")) {
+            return pattern.slice(1);
+        }
+        return `!${pattern}`;
+    });
+}
+exports.invertMatchPatterns = invertMatchPatterns;
+/**
+ * Gets all the files in the directory recursively while avoiding any micromatch patterns
+ * that would match for ignoring
+ *
+ * @param dir
+ * @param ignorePatterns
+ * @returns
+ */
+function getAllFilesInDir(dir, ignorePatterns) {
+    return recurseDirsForFiles(dir, ignorePatterns);
+}
+exports.getAllFilesInDir = getAllFilesInDir;
+function recurseDirsForFiles(dirpath, ignorePatterns, relativeRoot = "") {
+    return (0, fs_1.readdirSync)(dirpath, {
+        withFileTypes: true,
+    }).reduce((files, f) => {
+        const relPath = (0, path_1.join)(relativeRoot, f.name);
+        if ((0, micromatch_1.some)(relPath, ignorePatterns)) {
+            return files;
+        }
+        // Ensure we aren't ignoring these folders explicitly
+        if (f.isDirectory()) {
+            files.push(...recurseDirsForFiles((0, path_1.join)(dirpath, f.name), ignorePatterns, relPath));
+        }
+        else {
+            files.push(relPath);
+        }
+        return files;
+    }, []);
+}

package/lib/esm/merge-file.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFile = void 0;
+const micromatch_1 = require("micromatch");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const load_plugin_1 = require("./load-plugin");
+const diff_1 = require("diff");
+const fs_extra_1 = require("fs-extra");
+/**
+ * Applies the merge to a file according to the context information.
+ *
+ * Returns true if merged and false if skipped
+ * @param relPath
+ * @param context
+ * @returns
+ */
+async function mergeFile(relPath, context) {
+    const { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } = context;
+    if ((0, micromatch_1.some)(relPath, localTemplateSyncConfig.ignore)) {
+        return {
+            ignoredDueToLocal: true,
+        };
+    }
+    const ext = (0, path_1.extname)(relPath);
+    const filePath = (0, path_1.join)(cwd, relPath);
+    const templatePath = (0, path_1.join)(tempCloneDir, relPath);
+    const mergeConfig = templateSyncConfig.merge?.[ext];
+    const localMergeConfig = localTemplateSyncConfig.merge?.[ext];
+    // Either write the merge or write
+    let fileContents;
+    const localChanges = [];
+    if ((0, fs_1.existsSync)(filePath) && (mergeConfig || localMergeConfig)) {
+        const originalCurrentFile = (await (0, promises_1.readFile)(filePath)).toString();
+        if (mergeConfig) {
+            // Apply the template's most recent merges
+            const handler = await (0, load_plugin_1.loadPlugin)(mergeConfig, ext, tempCloneDir);
+            const mergeOptions = mergeConfig.rules.find((rule) => {
+                return (0, micromatch_1.isMatch)(relPath, rule.glob);
+            });
+            if (mergeOptions) {
+                fileContents = await safeMerge(handler, mergeConfig.plugin ?? `default for ${ext}`, originalCurrentFile, (await (0, promises_1.readFile)(templatePath)).toString(), {
+                    relFilePath: relPath,
+                    mergeArguments: mergeOptions.options,
+                    isLocalOptions: true,
+                });
+            }
+            else {
+                // Apply overwrite if we didn't set up merge
+                fileContents = (await (0, promises_1.readFile)(templatePath)).toString();
+            }
+        }
+        else {
+            // Apply overwrite if we didn't set up merge
+            fileContents = (await (0, promises_1.readFile)(templatePath)).toString();
+        }
+        // We apply the localMerge Config to the fileContent output by the template merge
+        if (localMergeConfig) {
+            const handler = await (0, load_plugin_1.loadPlugin)(localMergeConfig, ext, cwd);
+            const mergeOptions = localMergeConfig.rules.find((rule) => {
+                return (0, micromatch_1.isMatch)(relPath, rule.glob);
+            });
+            if (mergeOptions) {
+                const localContents = await safeMerge(handler, localMergeConfig.plugin ?? `default for ${ext}`, originalCurrentFile, fileContents, {
+                    relFilePath: relPath,
+                    mergeArguments: mergeOptions.options,
+                    isLocalOptions: true,
+                });
+                localChanges.push(...(0, diff_1.diffLines)(fileContents, localContents));
+                fileContents = localContents;
+            }
+        }
+    }
+    else {
+        // Just perform simple overwrite
+        fileContents = (await (0, promises_1.readFile)(templatePath)).toString();
+    }
+    await (0, fs_extra_1.outputFile)(filePath, fileContents);
+    return {
+        ignoredDueToLocal: false,
+        localChanges,
+    };
+}
+exports.mergeFile = mergeFile;
+/**
+ * Simple helper function to ensure that we don't let bad plugins corrupt the call flow
+ * @param plugin
+ */
+async function safeMerge(plugin, pluginPath, current, fromTemplate, context) {
+    const ret = await plugin.merge(current, fromTemplate, context);
+    if (typeof ret !== "string") {
+        throw new Error(`Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`);
+    }
+    if (!ret) {
+        throw new Error(`Plugin ${pluginPath} should not make a merge be an empty string!`);
+    }
+    return ret;
+}

package/lib/esm/plugins/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultExtensionMap = void 0;
+const json_merge_1 = require("./json-merge");
+exports.defaultExtensionMap = {
+    ".json": {
+        merge: json_merge_1.merge,
+        validate: json_merge_1.validate,
+    },
+};

package/lib/esm/plugins/json-merge.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = exports.validate = void 0;
+const lodash_merge_1 = __importDefault(require("lodash.merge"));
+const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+const jsonpath_1 = __importDefault(require("jsonpath"));
+const infer_json_indent_1 = require("../formatting/infer-json-indent");
+function stringOptionError(value) {
+    if (value === "overwrite" ||
+        value === "merge-template" ||
+        value === "merge-current") {
+        return;
+    }
+    return `${value} must be one of type overwrite, merge-template, or merge-current`;
+}
+function validate(options) {
+    const errors = [];
+    // check for flat options
+    if (typeof options === "string") {
+        const errMsg = stringOptionError(options);
+        if (errMsg) {
+            errors.push(errMsg);
+        }
+        return errors;
+    }
+    else {
+        if (typeof options !== "object") {
+            errors.push(`Options must be an object and not ${typeof options}`);
+            return errors;
+        }
+        if (Array.isArray(options)) {
+            errors.push(`Options must be an object and not Array`);
+            return errors;
+        }
+        if (options === null) {
+            errors.push("Options cannot be null");
+            return errors;
+        }
+    }
+    const optionsCast = options;
+    const optionKeys = Object.keys(optionsCast);
+    optionKeys.forEach((k) => {
+        if (k === "paths") {
+            optionsCast.paths.forEach((pathObj) => {
+                const [jsonPath, options] = pathObj;
+                if (jsonPath.startsWith("$.")) {
+                    try {
+                        jsonpath_1.default.parse(jsonPath);
+                    }
+                    catch (err) {
+                        errors.push(`Invalid jsonpath key: ${err}`);
+                        return;
+                    }
+                    const errMsg = stringOptionError(options);
+                    if (errMsg) {
+                        errors.push(`jsonpath ${jsonPath}: ${errMsg}`);
+                    }
+                }
+                else {
+                    errors.push(`Unrecognized jsonpath syntax: ${jsonPath}`);
+                }
+            });
+        }
+        else {
+            if (k === "ignoreNewProperties" || k === "missingIsDelete") {
+                return;
+            }
+            errors.push(`Unrecognized key: ${k}`);
+        }
+    });
+    return errors;
+}
+exports.validate = validate;
+async function merge(current, fromTemplateRepo, context) {
+    if (context.mergeArguments === "overwrite") {
+        return fromTemplateRepo;
+    }
+    const currentJson = JSON.parse(current);
+    const fromTemplateJson = JSON.parse(fromTemplateRepo);
+    if (context.mergeArguments === "merge-current") {
+        // Performs Lodash Merge with current as the override
+        return JSON.stringify((0, lodash_merge_1.default)(fromTemplateJson, currentJson), null, 4);
+    }
+    if (context.mergeArguments === "merge-template") {
+        // Performs Lodash Merge with current as the override
+        return JSON.stringify((0, lodash_merge_1.default)(currentJson, fromTemplateJson), null, 4);
+    }
+    const { missingIsDelete, ignoreNewProperties, paths } = context.mergeArguments;
+    const returnJson = (0, lodash_clonedeep_1.default)(currentJson);
+    paths.forEach((p) => {
+        const [jPath, overrideType] = p;
+        const fromTemplatePaths = new Map();
+        if (overrideType === "merge-template") {
+            // We want to make sure there aren't extra paths from the template that didn't get added
+            jsonpath_1.default.nodes(fromTemplateJson, jPath).forEach((n) => {
+                fromTemplatePaths.set(jsonpath_1.default.stringify(n.path), n.path);
+            });
+        }
+        jsonpath_1.default.nodes(currentJson, jPath).forEach(({ path, value }) => {
+            // This solves for wildcard operators
+            const fullPath = jsonpath_1.default.stringify(path);
+            // track the paths in the template we've walked
+            fromTemplatePaths.delete(fullPath);
+            jsonpath_1.default.apply(returnJson, fullPath, () => {
+                const templateValue = jsonpath_1.default.value(fromTemplateJson, fullPath);
+                if (overrideType === "merge-template") {
+                    if (templateValue === undefined) {
+                        if (missingIsDelete) {
+                            return templateValue;
+                        }
+                    }
+                    else {
+                        return applyValueMerge(value, templateValue);
+                    }
+                }
+                else if (overrideType === "merge-current") {
+                    return applyValueMerge(templateValue, value);
+                }
+                else if (overrideType === "overwrite") {
+                    if (templateValue !== undefined || missingIsDelete) {
+                        return templateValue;
+                    }
+                }
+                else {
+                    throw new Error(`Unexpected JsonPath merge value ${overrideType}`);
+                }
+                return value;
+            });
+        });
+        if (!ignoreNewProperties) {
+            for (const fromTemplatePath of fromTemplatePaths.values()) {
+                applyPerPath(fromTemplatePath, returnJson, fromTemplateJson);
+            }
+        }
+    });
+    if (!ignoreNewProperties) {
+        Object.keys(fromTemplateJson).forEach((key) => {
+            if (!returnJson[key]) {
+                returnJson[key] = fromTemplateJson[key];
+            }
+        });
+    }
+    return JSON.stringify(returnJson, null, (0, infer_json_indent_1.inferJSONIndent)(current));
+}
+exports.merge = merge;
+/**
+ * A merge from a template to template perspective is either melding objects
+ * or completely overwriting primitive types
+ */
+function applyValueMerge(base, toMerge) {
+    if (typeof base === "object" && typeof toMerge === "object") {
+        return (0, lodash_merge_1.default)(base, toMerge);
+    }
+    else {
+        return toMerge;
+    }
+}
+/**
+ * Given a nodePath on the "map" tree, this will go to the first missing element
+ * and copy that node onto the object
+ *
+ * @param nodePath
+ * @param onto
+ * @param map
+ * @param forIdx
+ */
+function applyPerPath(nodePath, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+onto, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+map, forIdx = 0) {
+    if (nodePath[forIdx] === "$") {
+        applyPerPath(nodePath, onto, map, forIdx + 1);
+        return;
+    }
+    const selector = nodePath[forIdx];
+    if (onto[selector]) {
+        applyPerPath(nodePath, onto[selector], map[selector], forIdx + 1);
+        return;
+    }
+    onto[selector] = map[selector];
+}

package/lib/esm/template-sync.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateSync = exports.TEMPLATE_SYNC_LOCAL_CONFIG = exports.TEMPLATE_SYNC_CONFIG = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const match_1 = require("./match");
+const merge_file_1 = require("./merge-file");
+const git_clone_1 = require("./clone-drivers/git-clone");
+const diff_drivers_1 = require("./diff-drivers");
+exports.TEMPLATE_SYNC_CONFIG = "templatesync";
+exports.TEMPLATE_SYNC_LOCAL_CONFIG = "templatesync.local";
+async function templateSync(options) {
+    const cloneDriver = options.cloneDriver ?? git_clone_1.gitClone;
+    const diffDriver = options.diffDriver ?? diff_drivers_1.gitDiff;
+    const tempCloneDir = await cloneDriver(options.tmpCloneDir, options.repoUrl);
+    // Get the clone Config
+    const cloneConfigPath = (0, path_1.join)(tempCloneDir, `${exports.TEMPLATE_SYNC_CONFIG}.json`);
+    const templateSyncConfig = (0, fs_1.existsSync)(cloneConfigPath)
+        ? JSON.parse((0, fs_1.readFileSync)(cloneConfigPath).toString())
+        : {};
+    const localConfigPath = (0, path_1.join)(options.repoDir, `${exports.TEMPLATE_SYNC_LOCAL_CONFIG}.json`);
+    const localTemplateSyncConfig = (0, fs_1.existsSync)(localConfigPath)
+        ? JSON.parse((0, fs_1.readFileSync)(localConfigPath).toString())
+        : {};
+    let filesToSync;
+    if (localTemplateSyncConfig.afterRef) {
+        filesToSync = await diffDriver(tempCloneDir, localTemplateSyncConfig.afterRef);
+    }
+    else {
+        filesToSync = (0, match_1.getAllFilesInDir)(tempCloneDir, [
+            ...templateSyncConfig.ignore,
+            ".git/**",
+        ]);
+    }
+    const localSkipFiles = [];
+    const localFileChanges = {};
+    await Promise.all(filesToSync.map(async (f) => {
+        const result = await (0, merge_file_1.mergeFile)(f, {
+            localTemplateSyncConfig,
+            templateSyncConfig,
+            tempCloneDir,
+            cwd: options.repoDir,
+        });
+        if (result.ignoredDueToLocal) {
+            localSkipFiles.push(f);
+        }
+        else if (result?.localChanges && result.localChanges.length > 0) {
+            localFileChanges[f] = result.localChanges;
+        }
+    }));
+    return {
+        localSkipFiles,
+        localFileChanges,
+    };
+}
+exports.templateSync = templateSync;

package/lib/esm/test-utils/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tempDir = exports.TEST_FIXTURES_DIR = void 0;
+const path_1 = require("path");
+const os_1 = require("os");
+exports.TEST_FIXTURES_DIR = (0, path_1.resolve)(__dirname, "..", "..", "test-fixtures");
+function tempDir() {
+    return process.env.RUNNER_TEMP ?? (0, os_1.tmpdir)();
+}
+exports.tempDir = tempDir;

package/lib/esm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@hanseltime/template-repo-sync",
+  "version": "1.0.1",
+  "description": "An npm library that enables pluggable, customizable synchronization between template repos",
+  "main": "lib/cjs/index.js",
+  "types": "lib/cjs/index.d.ts",
+  "module": "lib/esm/index.js",
+  "scripts": {
+    "format": "npx prettier . --write",
+    "lint": "npx eslint .",
+    "test": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" jest",
+    "run-script": "node --loader ts-node/esm",
+    "build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json",
+    "prepare": "husky",
+    "release": "npx semantic-release"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@actions/core": "^1.10.1",
+    "@actions/github": "^6.0.0",
+    "diff": "^5.1.0",
+    "fs-extra": "^11.2.0",
+    "jsonpath": "^1.1.1",
+    "lodash.clonedeep": "^4.5.0",
+    "lodash.merge": "^4.6.2",
+    "micromatch": "^4.0.5"
+  },
+  "devDependencies": {
+    "@commitlint/config-angular": "^19.0.3",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/diff": "^5.0.9",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.11",
+    "@types/jsonpath": "^0.2.4",
+    "@types/lodash.clonedeep": "^4.5.9",
+    "@types/lodash.merge": "^4.6.9",
+    "@types/micromatch": "^4.0.6",
+    "@types/node": "^20.11.7",
+    "colors": "^1.4.0",
+    "commitlint": "^19.0.3",
+    "eslint": "^8.57.0",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "prettier": "3.2.5",
+    "semantic-release": "^23.0.2",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^7.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/release.config.js

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { readFileSync } = require("fs");
+const { join } = require("path");
+
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, "package.json")).toString(),
+);
+
+// Abbreviate for Git Commit readability
+const fullName = packageJson.name;
+const scopeLimiterIdx = fullName.lastIndexOf("/");
+const abbreviatedName = fullName.substring(
+  scopeLimiterIdx >= 0 ? scopeLimiterIdx + 1 : 0,
+);
+
+module.exports = {
+  branches: ["main", { name: "alpha", prerelease: true }],
+  plugins: [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm",
+    [
+      "@semantic-release/git",
+      {
+        assets: ["CHANGELOG.md", "package.json"],
+        message: `docs(release): ${abbreviatedName} $\{nextRelease.version} [skip ci]\n\n$\{nextRelease.notes}`,
+      },
+    ],
+    // This creates a release on github - you can decide if you want to mirror the files in package.json
+    "@semantic-release/github",
+  ],
+  ci: true,
+};

package/src/clone-drivers/git-clone.ts

@@ -0,0 +1,16 @@
+import { execSync } from "child_process";
+import { resolve } from "path";
+
+const CLONE_DIR = "cloned_repo";
+
+export async function gitClone(
+  tmpDir: string,
+  repoUrl: string,
+): Promise<string> {
+  execSync(`git clone ${repoUrl} ${CLONE_DIR}`, {
+    cwd: tmpDir,
+    env: process.env,
+  });
+
+  return resolve(tmpDir, CLONE_DIR);
+}

package/src/clone-drivers/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./git-clone";

package/src/clone-drivers/types.ts

@@ -0,0 +1,8 @@
+/**
+ * A function that clones the template repo into the provided tmpDir
+ * and then returns the relative path within that directory to the template root
+ */
+export type TemplateCloneDriverFn = (
+  tmpDir: string,
+  repoUrl: string,
+) => Promise<string>;

package/src/diff-drivers/git-diff.ts

@@ -0,0 +1,10 @@
+import { execSync } from "child_process";
+
+export async function gitDiff(gitDir: string, afterRef: string) {
+  const diffFilesStr = execSync(`git diff ${afterRef}.. --name-only`, {
+    cwd: gitDir,
+  })
+    .toString()
+    .trim();
+  return diffFilesStr.split("\n");
+}

package/src/diff-drivers/index.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./git-diff";