@mxml3gend/gloss 0.1.1 → 0.1.3

package/dist/config.js

@@ -27,10 +27,70 @@ const normalizeScanConfig = (value) => {
     const scan = value;
     const include = normalizeScanPatterns(scan.include);
     const exclude = normalizeScanPatterns(scan.exclude);
-    if (!include && !exclude) {
+    const mode = scan.mode === "regex" || scan.mode === "ast" ? scan.mode : undefined;
+    if (!include && !exclude && !mode) {
         return undefined;
     }
-    return { include, exclude };
+    return { include, exclude, mode };
+};
+const DEFAULT_HARDCODED_MIN_LENGTH = 3;
+const DEFAULT_STRICT_PLACEHOLDERS = true;
+const normalizeStrictPlaceholders = (value) => {
+    if (value === undefined) {
+        return DEFAULT_STRICT_PLACEHOLDERS;
+    }
+    if (typeof value !== "boolean") {
+        throw new GlossConfigError("INVALID_CONFIG", "`strictPlaceholders` must be a boolean when provided.");
+    }
+    return value;
+};
+const normalizeHardcodedTextConfig = (value) => {
+    if (value === undefined) {
+        return {
+            enabled: true,
+            minLength: DEFAULT_HARDCODED_MIN_LENGTH,
+            excludePatterns: [],
+        };
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new GlossConfigError("INVALID_CONFIG", "`hardcodedText` must be an object when provided.");
+    }
+    const hardcodedText = value;
+    const enabled = typeof hardcodedText.enabled === "boolean" ? hardcodedText.enabled : true;
+    const minLength = typeof hardcodedText.minLength === "number" &&
+        Number.isFinite(hardcodedText.minLength) &&
+        hardcodedText.minLength >= 1
+        ? Math.floor(hardcodedText.minLength)
+        : DEFAULT_HARDCODED_MIN_LENGTH;
+    if (hardcodedText.minLength !== undefined &&
+        (typeof hardcodedText.minLength !== "number" ||
+            !Number.isFinite(hardcodedText.minLength) ||
+            hardcodedText.minLength < 1)) {
+        throw new GlossConfigError("INVALID_CONFIG", "`hardcodedText.minLength` must be a number >= 1 when provided.");
+    }
+    if (hardcodedText.excludePatterns !== undefined &&
+        !Array.isArray(hardcodedText.excludePatterns)) {
+        throw new GlossConfigError("INVALID_CONFIG", "`hardcodedText.excludePatterns` must be a string array when provided.");
+    }
+    const excludePatterns = Array.isArray(hardcodedText.excludePatterns)
+        ? hardcodedText.excludePatterns
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)
+        : [];
+    for (const pattern of excludePatterns) {
+        try {
+            void new RegExp(pattern);
+        }
+        catch {
+            throw new GlossConfigError("INVALID_CONFIG", `Invalid regex in hardcodedText.excludePatterns: ${pattern}`);
+        }
+    }
+    return {
+        enabled,
+        minLength,
+        excludePatterns,
+    };
 };
 const CONFIG_FILE_NAMES = [
     "gloss.config.ts",
@@ -39,6 +99,37 @@ const CONFIG_FILE_NAMES = [
     "gloss.config.mjs",
     "gloss.config.cjs",
 ];
+const LOCALE_CODE_PATTERN = /^[A-Za-z]{2,3}(?:[-_][A-Za-z0-9]{2,8})*$/;
+const AUTO_DISCOVERY_IGNORED_DIRECTORIES = new Set([
+    "node_modules",
+    ".git",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    "dist",
+    "build",
+    "coverage",
+    "out",
+]);
+const DIRECTORY_NAME_SCORES = new Map([
+    ["i18n", 80],
+    ["locales", 80],
+    ["locale", 60],
+    ["translations", 55],
+    ["translation", 45],
+    ["lang", 35],
+    ["langs", 35],
+    ["messages", 25],
+]);
+const normalizePath = (filePath) => filePath.split(path.sep).join("/").replace(/^\.\//, "");
+const isLikelyLocaleCode = (value) => LOCALE_CODE_PATTERN.test(value);
+const scoreDirectoryName = (directoryPath) => {
+    const segments = normalizePath(directoryPath).split("/");
+    return segments.reduce((score, segment) => {
+        const nextScore = DIRECTORY_NAME_SCORES.get(segment.toLowerCase());
+        return score + (nextScore ?? 0);
+    }, 0);
+};
 const resolveLocalesDirectory = (cwd, localesPath) => {
     if (path.isAbsolute(localesPath)) {
         return localesPath;
@@ -49,9 +140,13 @@ const discoverLocales = async (cwd, localesPath) => {
     const directory = resolveLocalesDirectory(cwd, localesPath);
     try {
         const entries = await fs.readdir(directory, { withFileTypes: true });
-        return entries
+        const localeCandidates = entries
             .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
             .map((entry) => path.basename(entry.name, ".json").trim())
+            .filter((entry) => entry.length > 0);
+        const likelyLocales = localeCandidates.filter(isLikelyLocaleCode);
+        const localesToUse = likelyLocales.length > 0 ? likelyLocales : localeCandidates;
+        return localesToUse
             .filter((entry) => entry.length > 0)
             .sort((a, b) => a.localeCompare(b));
     }
@@ -59,6 +154,83 @@ const discoverLocales = async (cwd, localesPath) => {
         return [];
     }
 };
+const discoverLocaleDirectoryCandidatesInternal = async (cwd) => {
+    const candidates = [];
+    const visit = async (directory) => {
+        const entries = await fs.readdir(directory, { withFileTypes: true });
+        const directoryLocales = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => path.basename(entry.name, ".json").trim())
+            .filter((entry) => isLikelyLocaleCode(entry));
+        if (directoryLocales.length > 0) {
+            const normalizedDirectory = normalizePath(path.relative(cwd, directory));
+            const uniqueLocales = Array.from(new Set(directoryLocales)).sort((a, b) => a.localeCompare(b));
+            const depth = normalizedDirectory.length === 0
+                ? 0
+                : normalizedDirectory.split("/").length;
+            candidates.push({
+                directoryPath: directory,
+                locales: uniqueLocales,
+                depth,
+            });
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (entry.name.startsWith(".") ||
+                AUTO_DISCOVERY_IGNORED_DIRECTORIES.has(entry.name)) {
+                continue;
+            }
+            await visit(path.join(directory, entry.name));
+        }
+    };
+    await visit(cwd);
+    return candidates;
+};
+const scoreLocaleDirectoryCandidates = (candidates, preferredLocales) => {
+    const scored = candidates.map((candidate) => {
+        const localeMatches = preferredLocales.filter((locale) => candidate.locales.includes(locale));
+        const allPreferredMatch = preferredLocales.length > 0 &&
+            preferredLocales.every((locale) => candidate.locales.includes(locale));
+        const directoryNameScore = scoreDirectoryName(candidate.directoryPath);
+        const srcHintScore = normalizePath(candidate.directoryPath).includes("/src/")
+            ? 15
+            : 0;
+        const depthScore = Math.max(0, 30 - candidate.depth * 3);
+        const localeCountScore = candidate.locales.length * 10;
+        const preferredScore = localeMatches.length * 25 + (allPreferredMatch ? 80 : 0);
+        const score = directoryNameScore +
+            srcHintScore +
+            depthScore +
+            localeCountScore +
+            preferredScore;
+        return { candidate, score };
+    });
+    scored.sort((left, right) => {
+        if (left.score !== right.score) {
+            return right.score - left.score;
+        }
+        if (left.candidate.depth !== right.candidate.depth) {
+            return left.candidate.depth - right.candidate.depth;
+        }
+        return left.candidate.directoryPath.localeCompare(right.candidate.directoryPath);
+    });
+    return scored;
+};
+const selectLocaleDirectoryCandidate = (candidates, preferredLocales) => {
+    return scoreLocaleDirectoryCandidates(candidates, preferredLocales)[0]?.candidate;
+};
+const resolveDiscoveredPath = (cwd, directoryPath) => {
+    const relative = path.relative(cwd, directoryPath);
+    if (!relative || relative === ".") {
+        return ".";
+    }
+    if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+        return normalizePath(relative);
+    }
+    return directoryPath;
+};
 const resolveConfigPath = async (cwd) => {
     for (const fileName of CONFIG_FILE_NAMES) {
         const candidatePath = path.join(cwd, fileName);
@@ -78,6 +250,17 @@ const normalizeLoadedConfig = (value) => {
     }
     return value;
 };
+export async function discoverLocaleDirectoryCandidates(cwdInput) {
+    const cwd = cwdInput ?? process.env.INIT_CWD ?? process.cwd();
+    const candidates = await discoverLocaleDirectoryCandidatesInternal(cwd);
+    const scored = scoreLocaleDirectoryCandidates(candidates, []);
+    return scored.map(({ candidate, score }) => ({
+        path: resolveDiscoveredPath(cwd, candidate.directoryPath),
+        locales: candidate.locales,
+        depth: candidate.depth,
+        score,
+    }));
+}
 export async function loadGlossConfig() {
     const cwd = process.env.INIT_CWD || process.cwd();
     const configPath = await resolveConfigPath(cwd);
@@ -93,10 +276,10 @@ export async function loadGlossConfig() {
         if (!cfg || typeof cfg !== "object") {
             throw new GlossConfigError("INVALID_CONFIG", "Default export must be a config object.");
         }
-        if (typeof cfg.path !== "string" || !cfg.path.trim()) {
-            throw new GlossConfigError("INVALID_CONFIG", "`path` must be a non-empty string.");
+        if (cfg.path !== undefined &&
+            (typeof cfg.path !== "string" || !cfg.path.trim())) {
+            throw new GlossConfigError("INVALID_CONFIG", "`path` must be a non-empty string when provided.");
         }
-        const translationsPath = cfg.path.trim();
         if (cfg.locales !== undefined && !Array.isArray(cfg.locales)) {
             throw new GlossConfigError("INVALID_CONFIG", "`locales` must be an array of locale codes when provided.");
         }
@@ -105,16 +288,35 @@ export async function loadGlossConfig() {
                 .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
                 .filter((entry) => entry.length > 0)
             : [];
+        const configuredPath = typeof cfg.path === "string" ? cfg.path.trim() : "";
+        const discoveredDirectoryCandidate = configuredPath
+            ? null
+            : selectLocaleDirectoryCandidate(await discoverLocaleDirectoryCandidatesInternal(cwd), configuredLocales);
+        const translationsPath = configuredPath
+            ? configuredPath
+            : discoveredDirectoryCandidate
+                ? resolveDiscoveredPath(cwd, discoveredDirectoryCandidate.directoryPath)
+                : "";
+        if (!translationsPath) {
+            throw new GlossConfigError("NO_LOCALES", "No locale directory found. Set `path` in config or add locale JSON files (for example `src/locales/en.json`).");
+        }
         const locales = configuredLocales.length > 0
             ? configuredLocales
-            : await discoverLocales(cwd, translationsPath);
+            : discoveredDirectoryCandidate
+                ? discoveredDirectoryCandidate.locales
+                : await discoverLocales(cwd, translationsPath);
         if (locales.length === 0) {
             throw new GlossConfigError("NO_LOCALES", `No locales found. Add "locales" in config or place *.json files in ${translationsPath}.`);
         }
-        if (typeof cfg.defaultLocale !== "string" || !cfg.defaultLocale.trim()) {
-            throw new GlossConfigError("INVALID_CONFIG", "`defaultLocale` must be a non-empty string.");
+        if (cfg.defaultLocale !== undefined &&
+            (typeof cfg.defaultLocale !== "string" || !cfg.defaultLocale.trim())) {
+            throw new GlossConfigError("INVALID_CONFIG", "`defaultLocale` must be a non-empty string when provided.");
         }
-        const defaultLocale = cfg.defaultLocale.trim();
+        const defaultLocale = typeof cfg.defaultLocale === "string" && cfg.defaultLocale.trim()
+            ? cfg.defaultLocale.trim()
+            : locales.includes("en")
+                ? "en"
+                : locales[0];
         if (!locales.includes(defaultLocale)) {
             throw new GlossConfigError("INVALID_CONFIG", "`defaultLocale` must be included in `locales`.");
         }
@@ -124,7 +326,9 @@ export async function loadGlossConfig() {
             defaultLocale,
             path: translationsPath,
             format: "json",
+            strictPlaceholders: normalizeStrictPlaceholders(cfg.strictPlaceholders),
             scan: normalizeScanConfig(cfg.scan),
+            hardcodedText: normalizeHardcodedTextConfig(cfg.hardcodedText),
         };
     }
     catch (e) {

package/dist/fs.js

@@ -1,5 +1,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+const DEFAULT_WRITE_LOCK_TIMEOUT_MS = 4_000;
+const DEFAULT_WRITE_LOCK_RETRY_MS = 50;
+const WRITE_LOCK_FILE_NAME = ".gloss-write.lock";
+export class WriteLockError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WriteLockError";
+    }
+}
 function projectRoot() {
     return process.env.INIT_CWD || process.cwd();
 }
@@ -12,6 +21,77 @@ function translationsDir(cfg) {
 function localeFile(cfg, locale) {
     return path.join(translationsDir(cfg), `${locale}.json`);
 }
+const compareKeys = (left, right) => {
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+};
+const isRecord = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const sortTranslationTree = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((entry) => sortTranslationTree(entry));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    const sorted = {};
+    const entries = Object.entries(value).sort(([leftKey], [rightKey]) => compareKeys(leftKey, rightKey));
+    for (const [key, entryValue] of entries) {
+        sorted[key] = sortTranslationTree(entryValue);
+    }
+    return sorted;
+};
+const sleep = (durationMs) => new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+});
+const parsePositiveInteger = (value, fallback) => {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return fallback;
+    }
+    return parsed;
+};
+const writeLockTimeoutMs = () => parsePositiveInteger(process.env.GLOSS_WRITE_LOCK_TIMEOUT_MS, DEFAULT_WRITE_LOCK_TIMEOUT_MS);
+const writeLockRetryMs = () => parsePositiveInteger(process.env.GLOSS_WRITE_LOCK_RETRY_MS, DEFAULT_WRITE_LOCK_RETRY_MS);
+const withTranslationsWriteLock = async (dir, run) => {
+    await fs.mkdir(dir, { recursive: true });
+    const lockFilePath = path.join(dir, WRITE_LOCK_FILE_NAME);
+    const timeoutMs = writeLockTimeoutMs();
+    const retryMs = writeLockRetryMs();
+    const startTime = Date.now();
+    let lockHandle = null;
+    while (!lockHandle) {
+        try {
+            lockHandle = await fs.open(lockFilePath, "wx");
+        }
+        catch (error) {
+            const errno = error;
+            if (errno.code !== "EEXIST") {
+                throw error;
+            }
+            if (Date.now() - startTime >= timeoutMs) {
+                throw new WriteLockError("Could not save translations because another Gloss save is in progress. Try again.");
+            }
+            await sleep(retryMs);
+        }
+    }
+    try {
+        return await run();
+    }
+    finally {
+        await lockHandle.close().catch(() => undefined);
+        await fs.unlink(lockFilePath).catch(() => undefined);
+    }
+};
 export async function readAllTranslations(cfg) {
     const out = {};
     for (const locale of cfg.locales) {
@@ -28,10 +108,29 @@ export async function readAllTranslations(cfg) {
 }
 export async function writeAllTranslations(cfg, data) {
     const dir = translationsDir(cfg);
-    await fs.mkdir(dir, { recursive: true });
-    for (const locale of cfg.locales) {
-        const file = localeFile(cfg, locale);
-        const json = JSON.stringify(data[locale] ?? {}, null, 2) + "\n";
-        await fs.writeFile(file, json, "utf8");
-    }
+    await withTranslationsWriteLock(dir, async () => {
+        const serialized = cfg.locales.map((locale) => {
+            return {
+                locale,
+                filePath: localeFile(cfg, locale),
+                json: JSON.stringify(sortTranslationTree(data[locale] ?? {}), null, 2) + "\n",
+            };
+        });
+        const operationId = `${Date.now()}-${process.pid}`;
+        const tempFiles = [];
+        try {
+            for (const entry of serialized) {
+                const tempPath = `${entry.filePath}.tmp-${operationId}-${entry.locale}`;
+                await fs.writeFile(tempPath, entry.json, "utf8");
+                tempFiles.push(tempPath);
+            }
+            for (let index = 0; index < serialized.length; index += 1) {
+                await fs.rename(tempFiles[index], serialized[index].filePath);
+            }
+        }
+        catch (error) {
+            await Promise.allSettled(tempFiles.map((filePath) => fs.unlink(filePath)));
+            throw error;
+        }
+    });
 }

package/dist/gitDiff.js

@@ -0,0 +1,113 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+import { readAllTranslations } from "./fs.js";
+import { flattenObject } from "./translationTree.js";
+const execFileAsync = promisify(execFile);
+const projectRoot = () => process.env.INIT_CWD || process.cwd();
+const normalizePath = (value) => value.split(path.sep).join("/");
+const runGit = async (cwd, args) => {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.trim();
+};
+const resolveLocaleFileRelativePath = (cfg, locale, cwd) => {
+    const directory = path.isAbsolute(cfg.path) ? cfg.path : path.resolve(cwd, cfg.path);
+    const filePath = path.resolve(directory, `${locale}.json`);
+    return normalizePath(path.relative(cwd, filePath));
+};
+const readJsonFromGit = async (cwd, ref, fileRelativePath) => {
+    if (!fileRelativePath ||
+        fileRelativePath.startsWith("../") ||
+        path.isAbsolute(fileRelativePath)) {
+        return {};
+    }
+    try {
+        const raw = await runGit(cwd, ["show", `${ref}:${fileRelativePath}`]);
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+export async function buildGitKeyDiff(cfg, baseRef = "origin/main") {
+    const cwd = projectRoot();
+    try {
+        const insideRepo = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+        if (insideRepo !== "true") {
+            return {
+                available: false,
+                baseRef,
+                generatedAt: new Date().toISOString(),
+                keys: [],
+                error: "Current directory is not a git repository.",
+            };
+        }
+    }
+    catch {
+        return {
+            available: false,
+            baseRef,
+            generatedAt: new Date().toISOString(),
+            keys: [],
+            error: "Git is not available in this project.",
+        };
+    }
+    let resolvedBaseRef = "";
+    try {
+        resolvedBaseRef = await runGit(cwd, ["rev-parse", "--verify", `${baseRef}^{commit}`]);
+    }
+    catch {
+        return {
+            available: false,
+            baseRef,
+            generatedAt: new Date().toISOString(),
+            keys: [],
+            error: `Base ref "${baseRef}" was not found.`,
+        };
+    }
+    const currentTranslations = await readAllTranslations(cfg);
+    const currentFlatByLocale = {};
+    const baseFlatByLocale = {};
+    for (const locale of cfg.locales) {
+        currentFlatByLocale[locale] = flattenObject((currentTranslations[locale] ?? {}));
+        const localeRelativePath = resolveLocaleFileRelativePath(cfg, locale, cwd);
+        const baseJson = await readJsonFromGit(cwd, resolvedBaseRef, localeRelativePath);
+        baseFlatByLocale[locale] = flattenObject(baseJson);
+    }
+    const allKeys = Array.from(new Set(cfg.locales.flatMap((locale) => [
+        ...Object.keys(baseFlatByLocale[locale] ?? {}),
+        ...Object.keys(currentFlatByLocale[locale] ?? {}),
+    ]))).sort((left, right) => left.localeCompare(right));
+    const keys = [];
+    for (const key of allKeys) {
+        const changes = [];
+        for (const locale of cfg.locales) {
+            const before = baseFlatByLocale[locale]?.[key] ?? "";
+            const after = currentFlatByLocale[locale]?.[key] ?? "";
+            if (before === after) {
+                continue;
+            }
+            const beforeMissing = before.trim() === "";
+            const afterMissing = after.trim() === "";
+            const kind = beforeMissing && !afterMissing
+                ? "added"
+                : !beforeMissing && afterMissing
+                    ? "removed"
+                    : "changed";
+            changes.push({ locale, kind, before, after });
+        }
+        if (changes.length > 0) {
+            keys.push({
+                key,
+                changes: changes.sort((left, right) => left.locale.localeCompare(right.locale)),
+            });
+        }
+    }
+    return {
+        available: true,
+        baseRef,
+        resolvedBaseRef,
+        generatedAt: new Date().toISOString(),
+        keys,
+    };
+}

package/dist/hooks.js

@@ -0,0 +1,101 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+const GLOSS_HOOK_MARKER = "# gloss-pre-commit";
+const GLOSS_HUSKY_MARKER = "# gloss-husky-hook";
+const GLOSS_HOOK_COMMAND = "npx gloss check --format human";
+const fileExists = async (filePath) => {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const resolveGitDir = (projectDir) => {
+    try {
+        const raw = execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: projectDir,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf8",
+        }).trim();
+        if (!raw) {
+            return null;
+        }
+        if (path.isAbsolute(raw)) {
+            return raw;
+        }
+        return path.resolve(projectDir, raw);
+    }
+    catch {
+        return null;
+    }
+};
+const writeExecutable = async (filePath, content) => {
+    await fs.writeFile(filePath, content, "utf8");
+    await fs.chmod(filePath, 0o755);
+};
+const installGitHook = async (hookPath) => {
+    const nextSnippet = `\n${GLOSS_HOOK_MARKER}\n${GLOSS_HOOK_COMMAND}\n`;
+    if (!(await fileExists(hookPath))) {
+        await writeExecutable(hookPath, `#!/bin/sh\nset -e${nextSnippet}`);
+        return "created";
+    }
+    const existing = await fs.readFile(hookPath, "utf8");
+    if (existing.includes(GLOSS_HOOK_MARKER) || existing.includes(GLOSS_HOOK_COMMAND)) {
+        return "skipped";
+    }
+    const suffix = existing.endsWith("\n") ? nextSnippet : `\n${nextSnippet}`;
+    await writeExecutable(hookPath, `${existing}${suffix}`);
+    return "updated";
+};
+const installHuskyHook = async (huskyDirectoryPath) => {
+    if (!(await fileExists(huskyDirectoryPath))) {
+        return "missing";
+    }
+    const hookPath = path.join(huskyDirectoryPath, "pre-commit");
+    const huskyBootstrapPath = path.join(huskyDirectoryPath, "_", "husky.sh");
+    const huskyBootstrapLine = `. "$(dirname -- "$0")/_/husky.sh"`;
+    const nextSnippet = `\n${GLOSS_HUSKY_MARKER}\n${GLOSS_HOOK_COMMAND}\n`;
+    if (!(await fileExists(hookPath))) {
+        const bootstrap = (await fileExists(huskyBootstrapPath))
+            ? `${huskyBootstrapLine}\n\n`
+            : "";
+        await writeExecutable(hookPath, `#!/usr/bin/env sh\n${bootstrap}${nextSnippet}`);
+        return "created";
+    }
+    const existing = await fs.readFile(hookPath, "utf8");
+    if (existing.includes(GLOSS_HUSKY_MARKER) || existing.includes(GLOSS_HOOK_COMMAND)) {
+        return "skipped";
+    }
+    const suffix = existing.endsWith("\n") ? nextSnippet : `\n${nextSnippet}`;
+    await writeExecutable(hookPath, `${existing}${suffix}`);
+    return "updated";
+};
+export async function installPreCommitHooks(projectDir, options) {
+    const messages = [];
+    const gitDir = options?.gitDirPath === undefined
+        ? resolveGitDir(projectDir)
+        : options.gitDirPath;
+    let gitHook = "missing";
+    if (gitDir) {
+        const hooksDir = path.join(gitDir, "hooks");
+        await fs.mkdir(hooksDir, { recursive: true });
+        gitHook = await installGitHook(path.join(hooksDir, "pre-commit"));
+        messages.push(`.git hook: ${gitHook}`);
+    }
+    else {
+        messages.push(".git hook: missing (not a git repository)");
+    }
+    const huskyHook = await installHuskyHook(path.join(projectDir, ".husky"));
+    messages.push(`husky hook: ${huskyHook}`);
+    if (gitHook === "missing" && huskyHook === "missing") {
+        messages.push("No hook target found. Initialize git or husky first.");
+    }
+    return {
+        gitHook,
+        huskyHook,
+        messages,
+    };
+}