@cldmv/git-embedded 1.0.0

package/src/api/commander/custom-help.mjs

@@ -0,0 +1,249 @@
+/**
+ * Build a `Help` subclass that renders colorized, multi-line help with the
+ * look the rest of the CLDMV CLIs use. The bin entry passes commander's
+ * statically imported `Help` class in once.
+ *
+ * `deps.chalk` is also passed by the bin: commander invokes the help methods
+ * outside any slothlet-tracked call, so the slothlet `context` proxy isn't
+ * live in those frames. Closing over the chalk dep keeps the help renderer
+ * standalone — it doesn't need the runtime to be active.
+ *
+ * @param {typeof import("commander").Help} HelpClass
+ * @param {{ chalk: import("chalk").ChalkInstance }} deps
+ * @returns {{ CustomHelp: typeof import("commander").Help, applyCustomHelpRecursive: Function }}
+ */
+export function makeCustomHelp(HelpClass, deps) {
+	const chalk = deps && deps.chalk;
+	if (!chalk) throw new Error("makeCustomHelp: deps.chalk is required");
+	class CustomHelp extends HelpClass {
+		static ensureHelpOption(cmd) {
+			if (typeof cmd.helpOption === "function" && !cmd.options.some((opt) => opt.long === "--help")) {
+				cmd.helpOption("-h, --help", "Show help for this command");
+			}
+			if (cmd.commands && cmd.commands.length) {
+				for (const sub of cmd.commands) CustomHelp.ensureHelpOption(sub);
+			}
+		}
+
+		constructor(opts = {}) {
+			super();
+			this.colorMode = typeof opts.colorMode === "string" ? opts.colorMode : "auto";
+			this.initColorMode();
+		}
+
+		formatHelp(cmd, helper) {
+			const color = (fn, str) => (this.colorMode === "never" ? str : fn(str));
+
+			const output = [];
+			const fullChain = getFullCommandChain(cmd);
+			const usageArgList = helper.visibleArguments(cmd);
+			const usageArgStr = usageArgList
+				.map((a) => {
+					const argStr = a.required ? `<${a.name()}>` : `[${a.name()}]`;
+					const colorFn = a.required ? chalk.magenta : chalk.yellow;
+					return color(colorFn, argStr);
+				})
+				.join(" ");
+			const usageOptionList = helper.visibleOptions(cmd).filter((o) => o.long !== "--help");
+			let usageLine = fullChain;
+			if (usageArgStr) usageLine += ` ${usageArgStr}`;
+			if (usageOptionList.length) usageLine += " [options]";
+			output.push(color(chalk.bold, "Usage:") + ` ${usageLine}`);
+			output.push("");
+
+			if (cmd.description()) {
+				output.push(color(chalk.bold, "Description:"));
+				output.push(cmd.description());
+				output.push("");
+			}
+
+			if (cmd._aliases && Array.isArray(cmd._aliases) && cmd._aliases.length > 0 && cmd.name() !== "help") {
+				output.push(color(chalk.bold, "Aliases:"));
+				for (const alias of cmd._aliases) output.push(`  ${color(chalk.yellow, alias)}`);
+				output.push("");
+			}
+
+			const commandList = helper.visibleCommands(cmd);
+			if (commandList.length) {
+				const isTopLevel = !cmd.parent;
+				output.push(color(chalk.bold, isTopLevel ? "Commands:" : "Sub Commands:"));
+				printCommands(commandList, 1, output, color, helper);
+			}
+
+			const optionList = helper.visibleOptions(cmd);
+			if (optionList.length) {
+				output.push(color(chalk.bold, "Options:"));
+				const width = optionList.reduce((max, o) => Math.max(max, helper.optionTerm(o).length), 0);
+				for (const o of optionList) {
+					const term = helper.optionTerm(o).padEnd(width);
+					output.push(`  ${color(chalk.green, term)}  ${o.description}`);
+				}
+				output.push("");
+			}
+
+			const argList = helper.visibleArguments(cmd);
+			if (argList.length) {
+				output.push(color(chalk.bold, "Arguments:"));
+				for (const a of argList) {
+					const argStr = a.required ? `<${a.name()}>` : `[${a.name()}]`;
+					const argColor = a.required ? chalk.magenta : chalk.yellow;
+					const desc = a.description ? `  ${a.description}` : "";
+					output.push(`  ${color(argColor, argStr)}${desc}`);
+				}
+				output.push("");
+			}
+
+			const examples = collectExamples(cmd);
+			if (examples.length) {
+				output.push(color(chalk.bold, "Examples:"));
+				const argPattern = /(<([\w|-]+)>)|(\[([\w|-]+)\])/g;
+				for (const ex of examples) {
+					const colored = ex.replace(argPattern, (match, p1, p2, p3, p4) => {
+						if (p2) return color(chalk.magenta, match);
+						if (p4) return color(chalk.yellow, match);
+						return match;
+					});
+					output.push(`  ${colored}`);
+				}
+				output.push("");
+			}
+
+			while (output.length > 0 && output[output.length - 1].trim() === "") output.pop();
+			output.push(color(chalk.gray, "\nFor more information, use a command with help, --help, or -h."));
+			output.push("");
+			return output.join("\n");
+		}
+
+		setColorMode(mode) {
+			this.colorMode = mode;
+			if (mode === "always") chalk.level = 3;
+			else if (mode === "never") chalk.level = 0;
+		}
+
+		initColorMode() {
+			if (process.env.NO_COLOR) this.setColorMode("never");
+			else if (process.env.FORCE_COLOR) this.setColorMode("always");
+		}
+	}
+
+	function applyCustomHelpRecursive(cmd) {
+		cmd.createHelp = () => new CustomHelp();
+		if (typeof cmd.showHelpAfterError === "function") cmd.showHelpAfterError(true);
+		CustomHelp.ensureHelpOption(cmd);
+		if (cmd.commands && cmd.commands.length) {
+			for (const sub of cmd.commands) applyCustomHelpRecursive(sub);
+		}
+	}
+
+	function printCommands(commands, indent, output, color, helper) {
+		for (const c of commands) {
+			let term = c.name();
+			if (c.options && c.options.some((opt) => opt.long !== "--help")) term += " [options]";
+			if (c._args && c._args.length) {
+				term +=
+					" " +
+					c._args
+						.map((a) => {
+							let name = a.name();
+							if (a.variadic) name += "...";
+							const argStr = a.required ? `<${name}>` : `[${name}]`;
+							const colorFn = a.required ? chalk.magenta : chalk.yellow;
+							return color(colorFn, argStr);
+						})
+						.join(" ");
+			}
+			let aliases = [];
+			if (Array.isArray(c._aliases)) aliases = c._aliases.filter((a) => a !== c.name());
+			else if (typeof c._aliases === "string" && c._aliases !== c.name()) aliases = [c._aliases];
+			const desc = (helper.commandDescription ? helper.commandDescription(c) : c.description()) || "";
+
+			const pad = "  ".repeat(indent);
+			const cmdColor = indent === 1 ? chalk.cyan : chalk.blueBright;
+			output.push(`${pad}${color(cmdColor, term)}`);
+			if (aliases.length) {
+				wrapTextWithHangingIndent(aliases.join(", "), indent + 1, "Aliases", (s) => color(chalk.yellow.italic, s)).forEach(
+					(l) => output.push(l)
+				);
+			}
+			if (desc) {
+				wrapTextWithHangingIndent(desc, indent + 1, "Description", (s) => color(chalk.gray.italic, s)).forEach((l) =>
+					output.push(l)
+				);
+			}
+			output.push("");
+
+			if (c.commands && c.commands.length) {
+				printCommands(helper.visibleCommands(c), indent + 1, output, color, helper);
+			}
+		}
+	}
+
+	return { CustomHelp, applyCustomHelpRecursive };
+}
+
+function getFullCommandChain(cmd) {
+	const names = [];
+	let current = cmd;
+	while (current) {
+		if (current.name && typeof current.name === "function") {
+			const n = current.name();
+			if (n) names.unshift(n);
+		}
+		current = current.parent;
+	}
+	return names.join(" ");
+}
+
+function wrapTextWithHangingIndent(text, indent, label, labelColor, width) {
+	const pad = "  ".repeat(indent);
+	const prefix = "- ";
+	const labelStr = label ? label + ": " : "";
+	const hangingPad = pad + " ".repeat(prefix.length + labelStr.length);
+	const maxWidth = (width || process.stdout.columns || 80) - (pad.length + prefix.length + labelStr.length);
+	const words = text.split(/\s+/);
+	const lines = [];
+	let line = "";
+	for (const word of words) {
+		if ((line + word).length > maxWidth) {
+			lines.push(line.trim());
+			line = word + " ";
+		} else {
+			line += word + " ";
+		}
+	}
+	if (line.trim()) lines.push(line.trim());
+	return lines.map((l, i) => (i === 0 ? pad + prefix + labelColor(labelStr) + l : hangingPad + l));
+}
+
+function collectExamples(cmd) {
+	if (!cmd.parent) {
+		const all = [];
+		walk(cmd, all);
+		const dedup = Array.from(new Set(all));
+		for (let i = dedup.length - 1; i > 0; i--) {
+			const j = Math.floor(Math.random() * (i + 1));
+			[dedup[i], dedup[j]] = [dedup[j], dedup[i]];
+		}
+		return dedup.slice(0, 5);
+	}
+	const own = cmd._exampleList;
+	const out = Array.isArray(own) ? own.slice() : [];
+	if (cmd.commands && cmd.commands.length) {
+		for (const sub of cmd.commands) {
+			const subName = sub.name();
+			const parentChain = getFullCommandChain(cmd);
+			let ex = `$ ${parentChain} ${subName}`;
+			const subArgs = (sub._args || []).map((a) => (a.required ? `<${a.name()}>` : `[${a.name()}]`)).join(" ");
+			if (subArgs) ex += ` ${subArgs}`;
+			if (!out.some((e) => e.includes(subName))) out.push(ex);
+		}
+	}
+	return out;
+}
+
+function walk(cmd, into) {
+	if (Array.isArray(cmd._exampleList)) for (const e of cmd._exampleList) into.push(e);
+	if (cmd.commands) for (const sub of cmd.commands) walk(sub, into);
+}
+
+export default { makeCustomHelp };

package/src/api/detect/dispatcher.mjs

@@ -0,0 +1,218 @@
+import { context } from "@cldmv/slothlet/runtime";
+
+export const REQUIRED_HOOKS = ["post-checkout", "post-merge", "post-rewrite", "reference-transaction"];
+
+export const STANDARD_HOOK_NAMES = [
+	"applypatch-msg",
+	"commit-msg",
+	"post-applypatch",
+	"post-checkout",
+	"post-commit",
+	"post-merge",
+	"post-rewrite",
+	"pre-applypatch",
+	"pre-auto-gc",
+	"pre-commit",
+	"pre-merge-commit",
+	"pre-push",
+	"pre-rebase",
+	"prepare-commit-msg",
+	"reference-transaction"
+];
+
+const DISPATCHER_MARKER = "# git-embedded-compatible dispatcher";
+
+const CHAIN_PATTERNS = [
+	/exec\s+"?\$repo_hook"?/,
+	/exec\s+"?\$\{?repo_hook\}?"?/,
+	/exec\s+"?\$git_dir\/hooks\/\$hook"?/
+];
+
+function readFull(p) {
+	try {
+		return context.fs.readFileSync(p, "utf8");
+	} catch {
+		return null;
+	}
+}
+
+function chainCheck(text) {
+	if (!text) return false;
+	return CHAIN_PATTERNS.some((re) => re.test(text));
+}
+
+/**
+ * Inspect a hooks directory and classify it. The return shape is one of:
+ *   { kind: "dispatcher-canonical-complete", dispatcherPath, missing: [], present: [...] }
+ *   { kind: "dispatcher-missing-symlinks", dispatcherPath, missing: [...], present: [...] }
+ *   { kind: "dispatcher-non-conforming", dispatcherPath, reason }
+ *   { kind: "bare-githooks", hookFiles: [...] }
+ *   { kind: "empty" }
+ *
+ * @param {string} dir
+ */
+export default function dispatcher(dir) {
+	const { fs, path } = context;
+	if (!dir) return { kind: "empty" };
+
+	let entries;
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return { kind: "empty", reason: "directory not readable" };
+	}
+
+	const fileEntries = entries.filter((e) => !e.name.startsWith("."));
+	if (fileEntries.length === 0) return { kind: "empty" };
+
+	let dispatcherPath = null;
+	const dispatchCandidate = path.join(dir, "_dispatch");
+	if (fs.existsSync(dispatchCandidate)) dispatcherPath = dispatchCandidate;
+
+	const byInode = new Map();
+	const symlinkTargets = new Map();
+	const realFiles = new Map();
+
+	for (const entry of fileEntries) {
+		const full = path.join(dir, entry.name);
+		let lst;
+		try {
+			lst = fs.lstatSync(full);
+		} catch {
+			continue;
+		}
+		if (lst.isSymbolicLink()) {
+			try {
+				const target = fs.readlinkSync(full);
+				const resolved = path.isAbsolute(target) ? target : path.resolve(dir, target);
+				symlinkTargets.set(entry.name, resolved);
+			} catch {
+				symlinkTargets.set(entry.name, null);
+			}
+		} else if (lst.isFile()) {
+			realFiles.set(entry.name, full);
+			const key = `${lst.dev}:${lst.ino}`;
+			if (!byInode.has(key)) byInode.set(key, []);
+			byInode.get(key).push(entry.name);
+		}
+	}
+
+	if (!dispatcherPath) {
+		let best = [];
+		for (const names of byInode.values()) {
+			const standard = names.filter((n) => STANDARD_HOOK_NAMES.includes(n));
+			if (standard.length >= 3 && standard.length > best.length) best = standard;
+		}
+		if (best.length > 0) dispatcherPath = path.join(dir, best[0]);
+	}
+
+	let copyClusterTarget = null;
+	if (!dispatcherPath && realFiles.size >= 3) {
+		const contentBuckets = new Map();
+		for (const [name, p] of realFiles) {
+			if (!STANDARD_HOOK_NAMES.includes(name)) continue;
+			try {
+				const key = fs.readFileSync(p).toString("base64");
+				if (!contentBuckets.has(key)) contentBuckets.set(key, []);
+				contentBuckets.get(key).push(name);
+			} catch {
+				continue;
+			}
+		}
+		let best = [];
+		for (const names of contentBuckets.values()) {
+			if (names.length >= 3 && names.length > best.length) best = names;
+		}
+		if (best.length > 0) {
+			copyClusterTarget = best;
+			dispatcherPath = path.join(dir, best[0]);
+		}
+	}
+
+	if (!dispatcherPath) {
+		const hookFiles = fileEntries.map((e) => e.name).filter((n) => STANDARD_HOOK_NAMES.includes(n) || !n.includes("."));
+		if (hookFiles.length === 0) return { kind: "empty" };
+		return { kind: "bare-githooks", dir, hookFiles };
+	}
+
+	const dispatcherText = readFull(dispatcherPath);
+	const hasChain = chainCheck(dispatcherText);
+	const hasMarker = dispatcherText && dispatcherText.includes(DISPATCHER_MARKER);
+
+	if (!hasChain) {
+		return {
+			kind: "dispatcher-non-conforming",
+			dir,
+			dispatcherPath,
+			reason: "dispatcher does not chain to per-repo hooks"
+		};
+	}
+
+	const dispatcherStat = (() => {
+		try {
+			return fs.statSync(dispatcherPath);
+		} catch {
+			return null;
+		}
+	})();
+	const dispatcherInodeKey = dispatcherStat ? `${dispatcherStat.dev}:${dispatcherStat.ino}` : null;
+	const dispatcherReal = (() => {
+		try {
+			return fs.realpathSync(dispatcherPath);
+		} catch {
+			return dispatcherPath;
+		}
+	})();
+
+	const present = [];
+	const missing = [];
+	for (const hook of REQUIRED_HOOKS) {
+		const full = path.join(dir, hook);
+		if (!fs.existsSync(full) && !symlinkTargets.has(hook)) {
+			missing.push(hook);
+			continue;
+		}
+
+		let resolved = null;
+		if (symlinkTargets.has(hook)) {
+			resolved = symlinkTargets.get(hook);
+		} else {
+			try {
+				resolved = fs.realpathSync(full);
+			} catch {
+				resolved = full;
+			}
+		}
+
+		if (resolved && path.resolve(resolved) === path.resolve(dispatcherReal)) {
+			present.push(hook);
+			continue;
+		}
+
+		try {
+			const lst = fs.lstatSync(full);
+			if (!lst.isSymbolicLink()) {
+				const st = fs.statSync(full);
+				const key = `${st.dev}:${st.ino}`;
+				if (key === dispatcherInodeKey) {
+					present.push(hook);
+					continue;
+				}
+			}
+		} catch {
+			// fall through
+		}
+
+		if (copyClusterTarget && copyClusterTarget.includes(hook)) {
+			present.push(hook);
+			continue;
+		}
+
+		missing.push(hook);
+	}
+
+	if (missing.length === 0) {
+		return { kind: "dispatcher-canonical-complete", dir, dispatcherPath, hasMarker, present };
+	}
+	return { kind: "dispatcher-missing-symlinks", dir, dispatcherPath, hasMarker, present, missing };
+}

package/src/api/detect/husky.mjs

@@ -0,0 +1,23 @@
+import { context } from "@cldmv/slothlet/runtime";
+
+/**
+ * Detect Husky in a repo.
+ *
+ * @param {string} repoRoot absolute path to the repo root
+ * @returns {{kind:"husky",dir:string,prepare:string|null,version:string|null}|null}
+ */
+export default function husky(repoRoot) {
+	if (!repoRoot) return null;
+	const { fs, path, wispSync } = context;
+	const dir = path.join(repoRoot, ".husky");
+	if (!fs.existsSync(dir)) return null;
+	let pkg = null;
+	try {
+		pkg = wispSync(path.join(repoRoot, "package.json"));
+	} catch {
+		pkg = null;
+	}
+	const prepare = pkg && pkg.scripts && pkg.scripts.prepare;
+	const version = pkg && ((pkg.devDependencies && pkg.devDependencies.husky) || (pkg.dependencies && pkg.dependencies.husky));
+	return { kind: "husky", dir, prepare: prepare || null, version: version || null };
+}

package/src/api/detect/lefthook.mjs

@@ -0,0 +1,37 @@
+import { context } from "@cldmv/slothlet/runtime";
+
+const CONFIG_NAMES = ["lefthook.yml", "lefthook.yaml", ".lefthook.yml", ".lefthook.yaml"];
+
+function readHead(p, n = 4) {
+	try {
+		return context.fs.readFileSync(p, "utf8").split(/\r?\n/).slice(0, n).join("\n");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Detect Lefthook in a repo.
+ *
+ * @param {string} repoRoot
+ * @param {string|null} gitDir
+ * @returns {{kind:"lefthook",configFile:string|null,headerIn?:string}|null}
+ */
+export default function lefthook(repoRoot, gitDir) {
+	if (!repoRoot) return null;
+	const { fs, path } = context;
+	const config = CONFIG_NAMES.map((c) => path.join(repoRoot, c)).find((p) => fs.existsSync(p));
+	if (config) return { kind: "lefthook", configFile: config };
+	if (gitDir) {
+		const hooksDir = path.join(gitDir, "hooks");
+		if (fs.existsSync(hooksDir)) {
+			for (const f of fs.readdirSync(hooksDir)) {
+				const head = readHead(path.join(hooksDir, f));
+				if (head && /lefthook/i.test(head)) {
+					return { kind: "lefthook", configFile: null, headerIn: path.join(hooksDir, f) };
+				}
+			}
+		}
+	}
+	return null;
+}

package/src/api/detect/pre-commit.mjs

@@ -0,0 +1,35 @@
+import { context } from "@cldmv/slothlet/runtime";
+
+function readHead(p, n = 4) {
+	try {
+		return context.fs.readFileSync(p, "utf8").split(/\r?\n/).slice(0, n).join("\n");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Detect Python pre-commit in a repo.
+ *
+ * @param {string} repoRoot
+ * @param {string|null} gitDir
+ * @returns {{kind:"pre-commit",configFile:string|null,headerIn?:string}|null}
+ */
+export default function preCommit(repoRoot, gitDir) {
+	if (!repoRoot) return null;
+	const { fs, path } = context;
+	const config = path.join(repoRoot, ".pre-commit-config.yaml");
+	if (fs.existsSync(config)) return { kind: "pre-commit", configFile: config };
+	if (gitDir) {
+		const hooksDir = path.join(gitDir, "hooks");
+		if (fs.existsSync(hooksDir)) {
+			for (const f of fs.readdirSync(hooksDir)) {
+				const head = readHead(path.join(hooksDir, f));
+				if (head && /File generated by pre-commit/i.test(head)) {
+					return { kind: "pre-commit", configFile: null, headerIn: path.join(hooksDir, f) };
+				}
+			}
+		}
+	}
+	return null;
+}

package/src/api/detect/run.mjs

@@ -0,0 +1,71 @@
+import { self, context } from "@cldmv/slothlet/runtime";
+
+/**
+ * Inspect `cwd` and return a structured classification. Foreign-manager
+ * checks (Husky / Lefthook / simple-git-hooks / pre-commit) take precedence
+ * over hooks-dir classification; system-scope `core.hooksPath` is reported
+ * with its sub-classification; otherwise the effective hooks dir is
+ * classified; otherwise `init.templateDir` fallback or "none".
+ *
+ * @param {string} [cwd]
+ */
+export default function run(cwd = process.cwd()) {
+	const { fs, path } = context;
+	const repoRoot = self.git.getRepoRoot(cwd);
+	const gitDir = self.git.getGitDir(cwd);
+	const scopes = self.git.getAllHooksPathScopes(cwd);
+	const effectiveHooksPath = self.git.getEffectiveHooksPath(cwd);
+	const initTemplateDir = self.git.getInitTemplateDir();
+
+	const paths = { repoRoot, gitDir, effectiveHooksPath, initTemplateDir };
+	const signals = { hooksPathScopes: scopes, initTemplateDir };
+
+	if (repoRoot) {
+		const husky = self.detect.husky(repoRoot);
+		if (husky) return { kind: "husky", paths, signals, foreign: husky, action: "refuse" };
+
+		const lefthook = self.detect.lefthook(repoRoot, gitDir);
+		if (lefthook) return { kind: "lefthook", paths, signals, foreign: lefthook, action: "refuse" };
+
+		const sgh = self.detect.simpleGitHooks(repoRoot);
+		if (sgh) return { kind: "simple-git-hooks", paths, signals, foreign: sgh, action: "refuse" };
+
+		const preCommit = self.detect.preCommit(repoRoot, gitDir);
+		if (preCommit) return { kind: "pre-commit", paths, signals, foreign: preCommit, action: "refuse" };
+	}
+
+	const systemPath = scopes.system;
+	if (systemPath && !scopes.global && !scopes.local) {
+		const sub = self.detect.dispatcher(effectiveHooksPath || systemPath);
+		return {
+			kind: "system-hookspath",
+			paths,
+			signals,
+			dispatcher: sub.kind.startsWith("dispatcher") ? sub : null,
+			subClassification: sub,
+			action: sub.kind === "dispatcher-canonical-complete" ? "install" : "refuse"
+		};
+	}
+
+	if (effectiveHooksPath) {
+		const sub = self.detect.dispatcher(effectiveHooksPath);
+		if (sub.kind === "dispatcher-canonical-complete") {
+			return { kind: "dispatcher-canonical-complete", paths, signals, dispatcher: sub, action: "install" };
+		}
+		if (sub.kind === "dispatcher-missing-symlinks") {
+			return { kind: "dispatcher-missing-symlinks", paths, signals, dispatcher: sub, action: "heal-then-install" };
+		}
+		if (sub.kind === "dispatcher-non-conforming") {
+			return { kind: "dispatcher-non-conforming", paths, signals, dispatcher: sub, action: "refuse" };
+		}
+		if (sub.kind === "bare-githooks") {
+			return { kind: "bare-githooks", paths, signals, bare: sub, action: "refuse" };
+		}
+	}
+
+	if (initTemplateDir && fs.existsSync(path.join(initTemplateDir, "hooks"))) {
+		return { kind: "init-templatedir", paths, signals, templateDir: initTemplateDir, action: "suggest-dispatcher" };
+	}
+
+	return { kind: "none", paths, signals, action: "suggest-dispatcher" };
+}

package/src/api/detect/simple-git-hooks.mjs

@@ -0,0 +1,26 @@
+import { context } from "@cldmv/slothlet/runtime";
+
+/**
+ * Detect simple-git-hooks in a repo.
+ *
+ * @param {string} repoRoot
+ * @returns {{kind:"simple-git-hooks",configIn:string,config?:object}|null}
+ */
+export default function simpleGitHooks(repoRoot) {
+	if (!repoRoot) return null;
+	const { fs, path, wispSync } = context;
+	let pkg = null;
+	try {
+		pkg = wispSync(path.join(repoRoot, "package.json"));
+	} catch {
+		pkg = null;
+	}
+	if (pkg && pkg["simple-git-hooks"]) {
+		return { kind: "simple-git-hooks", configIn: "package.json", config: pkg["simple-git-hooks"] };
+	}
+	const standalone = path.join(repoRoot, ".simple-git-hooks.json");
+	if (fs.existsSync(standalone)) {
+		return { kind: "simple-git-hooks", configIn: standalone };
+	}
+	return null;
+}