@stupify/cli 0.0.2 → 0.0.4

package/dist/constants.js

@@ -0,0 +1,53 @@
+export const VERSION = "0.0.4";
+export const DEFAULT_MODEL_ID = "gemma-4-e2b";
+export const MODEL_REGISTRY = {
+    "gemma-4-e2b": {
+        id: "gemma-4-e2b",
+        name: "Gemma 4 E2B Instruct Q4_K_M",
+        size: "about 3.1 GB",
+        file: "gemma-4-e2b-it-q4_k_m.gguf",
+        url: "https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF/resolve/main/gemma-4-E2B-it-Q4_K_M.gguf?download=true",
+    },
+    "gemma-4-e4b": {
+        id: "gemma-4-e4b",
+        name: "Gemma 4 E4B Instruct Q4_K_M",
+        size: "about 5.0 GB",
+        file: "gemma-4-e4b-it-q4_k_m.gguf",
+        url: "https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF/resolve/main/gemma-4-E4B-it-Q4_K_M.gguf?download=true",
+    },
+    "gemma-4-26b-a4b": {
+        id: "gemma-4-26b-a4b",
+        name: "Gemma 4 26B A4B Instruct UD-IQ2_XXS",
+        size: "about 9.9 GB",
+        file: "gemma-4-26b-a4b-it-ud-iq2_xxs.gguf",
+        url: "https://huggingface.co/unsloth/gemma-4-26B-A4B-it-GGUF/resolve/main/gemma-4-26B-A4B-it-UD-IQ2_XXS.gguf?download=true",
+    },
+    "qwen3-4b-magicquant": {
+        id: "qwen3-4b-magicquant",
+        name: "Qwen3-4B-Instruct-2507 MagicQuant Q4_K_M",
+        size: "about 2.4 GB",
+        file: "qwen3-4b-instruct-2507-magicquant-q4_k_m.gguf",
+        url: "https://huggingface.co/magiccodingman/Qwen3-4B-Instruct-2507-Unsloth-MagicQuant-v2-GGUF/resolve/main/Model-MQ-Q4_K_M_1.gguf?download=true",
+    },
+    "qwen2.5-coder-1.5b": {
+        id: "qwen2.5-coder-1.5b",
+        name: "Qwen2.5-Coder-1.5B-Instruct Q4_K_M",
+        size: "about 1.1 GB",
+        file: "qwen2.5-coder-1.5b-instruct-q4_k_m.gguf",
+        url: "https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct-GGUF/resolve/main/qwen2.5-coder-1.5b-instruct-q4_k_m.gguf?download=true",
+    },
+    "qwen2.5-coder-7b": {
+        id: "qwen2.5-coder-7b",
+        name: "Qwen2.5-Coder-7B-Instruct Q4_K_M",
+        size: "about 4.7 GB",
+        file: "qwen2.5-coder-7b-instruct-q4_k_m.gguf",
+        url: "https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct-GGUF/resolve/main/qwen2.5-coder-7b-instruct-q4_k_m.gguf?download=true",
+    },
+    "qwen2.5-coder-32b": {
+        id: "qwen2.5-coder-32b",
+        name: "Qwen2.5-Coder-32B-Instruct Q4_K_M",
+        size: "about 19 GB",
+        file: "qwen2.5-coder-32b-instruct-q4_k_m.gguf",
+        url: "https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct-GGUF/resolve/main/qwen2.5-coder-32b-instruct-q4_k_m.gguf?download=true",
+    },
+};

package/dist/counter-scout.d.ts

@@ -0,0 +1,14 @@
+import type { CheckId, SemCandidate, SemChangeSet, StupifyCheck } from "./types.ts";
+type Signal = Readonly<{
+    checkId: CheckId;
+    entityId: string;
+    reasonCode: string;
+}>;
+type SignalBucket = Readonly<{
+    checkId: CheckId;
+    total: number;
+    examples: readonly Signal[];
+}>;
+export declare function counterScoutTargets(changeSet: SemChangeSet, checks: readonly StupifyCheck[], maxTargets: number): readonly SemCandidate[];
+export declare function runSignalCounters(changeSet: SemChangeSet, checks: readonly StupifyCheck[]): readonly SignalBucket[];
+export {};

package/dist/counter-scout.js

@@ -0,0 +1,159 @@
+const MAX_COUNTER_EXAMPLES_PER_CHECK = 4;
+export function counterScoutTargets(changeSet, checks, maxTargets) {
+    const buckets = runSignalCounters(changeSet, checks);
+    const targets = [];
+    let cursor = 0;
+    while (targets.length < maxTargets && buckets.some((bucket) => cursor < bucket.examples.length)) {
+        for (const bucket of buckets) {
+            const signal = bucket.examples[cursor];
+            if (!signal)
+                continue;
+            targets.push({
+                sourceId: changeSet.id,
+                targetId: `t${String(targets.length + 1).padStart(3, "0")}`,
+                entityId: signal.entityId,
+                checkId: signal.checkId,
+                reason: signal.reasonCode,
+            });
+            if (targets.length >= maxTargets)
+                break;
+        }
+        cursor += 1;
+    }
+    return targets;
+}
+export function runSignalCounters(changeSet, checks) {
+    return checks
+        .map((check) => {
+        const signals = changeSet.changes.flatMap((change) => {
+            const reasonCode = reasonForCheck(check.id, change);
+            return reasonCode ? [{ checkId: check.id, entityId: change.entityId, reasonCode }] : [];
+        });
+        return {
+            checkId: check.id,
+            total: signals.length,
+            examples: signals.slice(0, MAX_COUNTER_EXAMPLES_PER_CHECK),
+        };
+    })
+        .filter((bucket) => bucket.total > 0);
+}
+function reasonForCheck(checkId, change) {
+    if (!isSearchableSourceChange(change))
+        return null;
+    const haystack = `${change.entityName}\n${change.entityType}\n${change.filePath}\n${change.afterContent ?? ""}`.toLowerCase();
+    const changed = change.changeType === "added" || change.changeType === "modified";
+    if (!changed)
+        return null;
+    switch (checkId) {
+        case "duplicated_schema":
+            return isDuplicatedSchemaCandidate(change) ? "local_schemaish_copy" : null;
+        case "unnecessary_complexity":
+            return /\b(helper|wrapper|service|provider|manager|factory|adapter|resolver|coordinator)\b/i.test(change.entityName)
+                ? "new_abstraction_name"
+                : null;
+        case "fake_precision_windowing":
+            return /\b(token|budget|window|batch|ratio|estimate|counter|count|limit)\b/i.test(haystack)
+                ? "precision_accounting_terms"
+                : null;
+        case "coauthored_slop":
+            return /\b(coauhtoried|coauthored|co-authored|co-authored-by)\b/i.test(haystack)
+                ? "coauthor_text"
+                : null;
+        case "mega_file":
+            return change.entityType === "chunk" && /lines\s+\d+-\d+/i.test(change.entityName)
+                ? "large_changed_chunk"
+                : null;
+        case "over_commenting":
+            return overCommentingSignal(change)
+                ? "comment_lines_increased"
+                : null;
+        case "lint_bypass":
+            return lintBypassSignal(change.afterContent ?? "")
+                ? "lint_or_type_bypass_text"
+                : null;
+        case "inconsistent_patterns":
+            return /\b(manager|factory|provider|adapter|orchestrator|coordinator)\b/i.test(change.entityName)
+                ? "pattern_abstraction_name"
+                : null;
+        case "reinvented_utils":
+            return reinventedUtilitySignal(change)
+                ? "generic_utility_name"
+                : null;
+        case "operator_style_mismatch":
+            return /\b(manager|factory|provider|enterprise|orchestrator)\b/i.test(haystack)
+                ? "style_smell_terms"
+                : null;
+        default:
+            return null;
+    }
+}
+function isDuplicatedSchemaCandidate(change) {
+    if (!/^(interface|type)$/i.test(change.entityType))
+        return false;
+    if (/^(public|external|internal|payment|.+client$)/i.test(change.entityName))
+        return false;
+    return /\b(local|payload|schema)\b/i.test(words(change.entityName));
+}
+function overCommentingSignal(change) {
+    const before = commentLines(change.beforeContent);
+    const after = commentLines(change.afterContent);
+    if (after <= before + 3)
+        return false;
+    const comments = commentText(change.afterContent);
+    if (/\b(because|why|constraint|provider|external|api|quirk|edge case|timezone|utc|ledger|finance|reconciliation|rejects|mirrors|keep this)\b/i.test(comments)) {
+        return false;
+    }
+    return true;
+}
+function lintBypassSignal(value) {
+    return value.split(/\r?\n/).some((line) => {
+        const trimmed = line.trim();
+        const comment = /^(\/\/|\/\*|\*)/.test(trimmed);
+        if (comment && /@ts-ignore\s*$/i.test(trimmed))
+            return true;
+        if (comment && /@ts-expect-error\s*$/i.test(trimmed))
+            return true;
+        if (comment && /(eslint-disable|biome-ignore)/i.test(trimmed) && !/\s--\s*\S/.test(trimmed))
+            return true;
+        return /\bas unknown as\b|\bas any\b|:\s*any\b/i.test(trimmed);
+    });
+}
+function reinventedUtilitySignal(change) {
+    const name = change.entityName;
+    if (!/^(clamp|debounce|throttle|slug|slugify|group|sort|shuffle|memoize|pick|omit|uniq)/i.test(name))
+        return false;
+    const content = change.afterContent ?? "";
+    if (/currency|invoice|refund|subscription|tier|domain/i.test(`${name}\n${content}`))
+        return false;
+    return true;
+}
+function isSearchableSourceChange(change) {
+    const filePath = change.filePath.toLowerCase();
+    if (/(^|\/)(bun|package-lock|pnpm-lock|yarn)\.lock$/.test(filePath))
+        return false;
+    if (/(^|\/)(dist|build|coverage|generated|vendor|fixtures?|snapshots?)(\/|$)/.test(filePath))
+        return false;
+    if (/\.(md|mdx|txt|json|jsonc|ya?ml|toml|lock|csv|svg|png|jpe?g|gif|webp)$/i.test(filePath))
+        return false;
+    if (/\.(test|spec|fixture)\.[cm]?[jt]sx?$/i.test(filePath))
+        return false;
+    return /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/i.test(filePath);
+}
+function commentLines(value) {
+    if (!value)
+        return 0;
+    return value.split(/\r?\n/).filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line)).length;
+}
+function commentText(value) {
+    if (!value)
+        return "";
+    return value
+        .split(/\r?\n/)
+        .filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line))
+        .join("\n");
+}
+function words(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ");
+}

package/dist/diff.d.ts

@@ -0,0 +1 @@
+export declare function readDiffFromStdin(): Promise<string>;

package/dist/diff.js

@@ -0,0 +1,10 @@
+import { stdin as input } from "node:process";
+export async function readDiffFromStdin() {
+    const chunks = [];
+    for await (const chunk of input)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    const text = Buffer.concat(chunks).toString("utf8");
+    if (!text.trim())
+        throw new Error("No diff received on stdin.");
+    return text;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,4 @@
+export declare function runDoctor(): Promise<Readonly<{
+    exitCode: number;
+    text: string;
+}>>;

package/dist/doctor.js

@@ -0,0 +1,131 @@
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+import { homedir, platform } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.js";
+import { runHookCommand } from "./hooks.js";
+const execFileAsync = promisify(execFile);
+export async function runDoctor() {
+    const checks = await Promise.all([
+        gitCheck(),
+        hookCheck(),
+        semCheck(),
+        repomixCheck(),
+        llamaServerCheck(),
+        modelCacheCheck(),
+    ]);
+    const requiredMissing = checks.some((check) => check.required && check.status === "missing");
+    return {
+        exitCode: requiredMissing ? 1 : 0,
+        text: renderDoctor(checks),
+    };
+}
+async function gitCheck() {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { maxBuffer: 1024 * 1024 });
+        return { label: "git repo", status: "ok", detail: stdout.trim(), required: true };
+    }
+    catch {
+        return { label: "git repo", status: "missing", detail: "not inside a git repository", required: true };
+    }
+}
+async function hookCheck() {
+    try {
+        const status = await runHookCommand("status");
+        return { label: "pre-commit hook", status: "info", detail: status.replace(/^Stupify hook:\s*/, "") };
+    }
+    catch (error) {
+        return { label: "pre-commit hook", status: "info", detail: errorMessage(error) };
+    }
+}
+async function semCheck() {
+    const packageBin = resolvePackage("@ataraxy-labs/sem/bin/sem.js");
+    if (packageBin)
+        return { label: "sem", status: "ok", detail: "@ataraxy-labs/sem package binary found", required: true };
+    if (await commandExists("sem"))
+        return { label: "sem", status: "ok", detail: "sem found on PATH", required: true };
+    return { label: "sem", status: "missing", detail: "install @ataraxy-labs/sem or put sem on PATH", required: true };
+}
+async function repomixCheck() {
+    if (resolvePackage("repomix"))
+        return { label: "Repomix", status: "ok", detail: "repomix package found", required: true };
+    return { label: "Repomix", status: "missing", detail: "repomix package is not installed", required: true };
+}
+async function llamaServerCheck() {
+    if (await commandExists("llama-server"))
+        return { label: "llama-server", status: "ok", detail: "llama-server found on PATH", required: true };
+    return { label: "llama-server", status: "missing", detail: "install llama.cpp, for example `brew install llama.cpp`", required: true };
+}
+async function modelCacheCheck() {
+    const model = MODEL_REGISTRY[DEFAULT_MODEL_ID];
+    const modelPath = path.join(cacheDir(), "models", model.file);
+    if (await fileExists(modelPath))
+        return { label: "default model", status: "ok", detail: `${model.name} cached` };
+    return {
+        label: "default model",
+        status: "info",
+        detail: `${model.name} not cached yet; first interactive search can download it locally`,
+    };
+}
+function renderDoctor(checks) {
+    const lines = [
+        "Stupify doctor",
+        "",
+        ...checks.map((check) => `${icon(check.status)} ${check.label}: ${check.detail}`),
+        "",
+        "Privacy: local-only. Stupify does not upload source, diffs, filenames, repo URLs, commit messages, author names, or private package names.",
+    ];
+    return lines.join("\n");
+}
+function icon(status) {
+    if (status === "ok")
+        return "OK";
+    if (status === "missing")
+        return "MISSING";
+    return "INFO";
+}
+function resolvePackage(specifier) {
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve(specifier);
+    }
+    catch {
+        return null;
+    }
+}
+async function commandExists(command) {
+    try {
+        await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        const { stat } = await import("node:fs/promises");
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function cacheDir() {
+    if (process.env.STUPIFY_CACHE_DIR)
+        return process.env.STUPIFY_CACHE_DIR;
+    if (process.env.XDG_CACHE_HOME)
+        return path.join(process.env.XDG_CACHE_HOME, "stupify");
+    if (platform() === "darwin")
+        return path.join(homedir(), "Library", "Caches", "stupify");
+    if (platform() === "win32" && process.env.LOCALAPPDATA)
+        return path.join(process.env.LOCALAPPDATA, "stupify", "Cache");
+    return path.join(homedir(), ".cache", "stupify");
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/git.d.ts

@@ -0,0 +1,11 @@
+import { type NetDiff, type SourceRange, type StagedDiff } from "./types.ts";
+export declare function netDiffSince(since: string): Promise<NetDiff>;
+export declare function netDiffForCommit(commit: string): Promise<NetDiff>;
+export declare function netDiffForRecentCommits(count: number): Promise<NetDiff>;
+export declare function sourceRangeSince(since: string): Promise<SourceRange>;
+export declare function sourceRangeForCommit(commit: string): Promise<SourceRange>;
+export declare function sourceRangeForRecentCommits(count: number): Promise<SourceRange>;
+export declare function netDiffFromStdin(text: string): Promise<NetDiff>;
+export declare function stagedDiff(): Promise<StagedDiff>;
+export declare function gitRoot(): Promise<string>;
+export declare function gitPath(pathspec: string): Promise<string>;

package/dist/git.js

@@ -0,0 +1,253 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { sourceId } from "./types.js";
+const execFileAsync = promisify(execFile);
+export async function netDiffSince(since) {
+    const range = await sourceRangeSince(since);
+    return netDiff(range.base, range.target, range.label, range.id);
+}
+export async function netDiffForCommit(commit) {
+    const range = await sourceRangeForCommit(commit);
+    return netDiff(range.base, range.target, range.label, range.id);
+}
+export async function netDiffForRecentCommits(count) {
+    const range = await sourceRangeForRecentCommits(count);
+    return netDiff(range.base, range.target, range.label, range.id);
+}
+export async function sourceRangeSince(since) {
+    const [base, target] = await Promise.all([baseBefore(since), revParse("HEAD")]);
+    return sourceRange(base, target, `last ${since}`);
+}
+export async function sourceRangeForCommit(commit) {
+    const [base, target, shortTarget, message] = await Promise.all([
+        revParse(`${commit}^1`),
+        revParse(commit),
+        shortCommit(commit),
+        commitMessage(commit),
+    ]);
+    return sourceRange(base, target, firstLine(message) || shortTarget, sourceId(shortTarget));
+}
+export async function sourceRangeForRecentCommits(count) {
+    const commits = await recentCommits(count);
+    if (commits.length === 0)
+        throw new Error("No non-merge commits found.");
+    const oldest = commits[0];
+    const newest = commits[commits.length - 1];
+    const [base, target, shortBase, shortTarget] = await Promise.all([
+        revParse(`${oldest}^1`),
+        revParse(newest),
+        shortCommit(`${oldest}^1`),
+        shortCommit(newest),
+    ]);
+    return sourceRange(base, target, `${commits.length} recent commits`, sourceId(`range:${shortBase}..${shortTarget}`));
+}
+export async function netDiffFromStdin(text) {
+    if (!text.trim())
+        throw new Error("No diff received on stdin.");
+    return {
+        id: sourceId("stdin"),
+        label: "stdin",
+        base: "stdin",
+        target: "stdin",
+        text,
+        stats: statsFromDiff(text),
+    };
+}
+export async function stagedDiff() {
+    try {
+        const { stdout } = await execFileAsync("git", [
+            "diff",
+            "--cached",
+            "--no-ext-diff",
+            "--no-color",
+            "--unified=3",
+            "--",
+        ], { maxBuffer: 64 * 1024 * 1024 });
+        return { text: stdout, stats: statsFromDiff(stdout) };
+    }
+    catch {
+        throw new Error("Could not read staged changes. Run stupify inside a git repository.");
+    }
+}
+export async function gitRoot() {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+        return stdout.trim();
+    }
+    catch {
+        throw new Error("Could not find a git repository.");
+    }
+}
+export async function gitPath(pathspec) {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", pathspec]);
+        return stdout.trim();
+    }
+    catch {
+        throw new Error(`Could not resolve git path: ${pathspec}`);
+    }
+}
+async function netDiff(base, target, label, id) {
+    const [text, stats, shortBase, shortTarget] = await Promise.all([
+        diff(base, target),
+        diffStats(base, target),
+        shortCommit(base),
+        shortCommit(target),
+    ]);
+    return {
+        id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
+        label,
+        base,
+        target,
+        text,
+        stats,
+    };
+}
+async function sourceRange(base, target, label, id) {
+    const [stats, shortBase, shortTarget] = await Promise.all([
+        diffStats(base, target),
+        shortCommit(base),
+        shortCommit(target),
+    ]);
+    return {
+        id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
+        label,
+        base,
+        target,
+        stats,
+    };
+}
+async function baseBefore(since) {
+    try {
+        const { stdout } = await execFileAsync("git", [
+            "log",
+            "--first-parent",
+            "--before",
+            since,
+            "-1",
+            "--format=%H",
+        ]);
+        const commit = stdout.trim();
+        if (commit)
+            return commit;
+        return rootCommit();
+    }
+    catch {
+        throw new Error(`Could not resolve base commit before ${since}.`);
+    }
+}
+async function rootCommit() {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-list", "--max-parents=0", "HEAD"]);
+        return stdout.trim().split(/\r?\n/, 1)[0] ?? "";
+    }
+    catch {
+        throw new Error("Could not resolve repository root commit.");
+    }
+}
+async function diff(base, target) {
+    try {
+        const { stdout } = await execFileAsync("git", [
+            "diff",
+            "--no-ext-diff",
+            "--no-color",
+            "--unified=8",
+            base,
+            target,
+            "--",
+        ], { maxBuffer: 128 * 1024 * 1024 });
+        if (!stdout.trim())
+            throw new Error("empty diff");
+        return stdout;
+    }
+    catch {
+        throw new Error(`No diff found for ${base}..${target}.`);
+    }
+}
+async function diffStats(base, target) {
+    try {
+        const { stdout } = await execFileAsync("git", ["diff", "--numstat", base, target, "--"], {
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        return statsFromNumstat(stdout);
+    }
+    catch {
+        return { filesChanged: 0, additions: 0, deletions: 0 };
+    }
+}
+function statsFromDiff(diffText) {
+    const files = new Set();
+    let additions = 0;
+    let deletions = 0;
+    for (const line of diffText.split(/\r?\n/)) {
+        const fileMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
+        if (fileMatch)
+            files.add(fileMatch[1]);
+        else if (line.startsWith("+") && !line.startsWith("+++"))
+            additions += 1;
+        else if (line.startsWith("-") && !line.startsWith("---"))
+            deletions += 1;
+    }
+    return { filesChanged: files.size, additions, deletions };
+}
+function statsFromNumstat(numstat) {
+    let filesChanged = 0;
+    let additions = 0;
+    let deletions = 0;
+    for (const line of numstat.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const [added, deleted] = line.split(/\s+/, 3);
+        filesChanged += 1;
+        additions += Number(added) || 0;
+        deletions += Number(deleted) || 0;
+    }
+    return { filesChanged, additions, deletions };
+}
+async function recentCommits(count) {
+    try {
+        const { stdout } = await execFileAsync("git", [
+            "log",
+            "--first-parent",
+            "--no-merges",
+            "--format=%H",
+            `-${count}`,
+        ]);
+        return stdout.split(/\r?\n/).filter(Boolean).reverse();
+    }
+    catch {
+        throw new Error(`Could not read last ${count} commits.`);
+    }
+}
+async function revParse(rev) {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", rev]);
+        return stdout.trim();
+    }
+    catch {
+        throw new Error(`Could not resolve ${rev}.`);
+    }
+}
+async function shortCommit(commit) {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--short", commit]);
+        return stdout.trim();
+    }
+    catch {
+        throw new Error(`Could not resolve commit ${commit}.`);
+    }
+}
+async function commitMessage(commit) {
+    try {
+        const { stdout } = await execFileAsync("git", ["show", "--no-patch", "--format=%B", commit], {
+            maxBuffer: 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch {
+        throw new Error(`Could not read commit message for ${commit}.`);
+    }
+}
+function firstLine(value) {
+    return value.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+}

package/dist/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { HookAction } from "./types.ts";
+export declare function runHookCommand(action: HookAction): Promise<string>;
+export declare function hookSnippet(): string;