@4-r-c-4-n-4/todo 0.1.4 → 0.1.5

package/dist/branch-guard.d.ts

@@ -0,0 +1,9 @@
+import type { Ticket } from "./types.js";
+export declare function expectedBranchFor(ticket: Ticket): string;
+export interface BranchCheck {
+    ok: boolean;
+    message?: string;
+}
+export declare function checkOnExpectedBranch(ticket: Ticket, currentBranch: string): BranchCheck;
+export declare function checkBranchHasTodoCommit(ticket: Ticket, repoRoot: string, commitPrefix: string): BranchCheck;
+export declare function checkWorkingTreeClean(repoRoot: string): BranchCheck;

package/dist/branch-guard.js

@@ -0,0 +1,53 @@
+"use strict";
+// Branch-convention guards used by `todo close` and `todo work`.
+//
+// These turn the conventions documented in the todo-implement skill into
+// hard preconditions: agents follow exit codes far more reliably than
+// prose, so every drift gets a clear, actionable error.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectedBranchFor = expectedBranchFor;
+exports.checkOnExpectedBranch = checkOnExpectedBranch;
+exports.checkBranchHasTodoCommit = checkBranchHasTodoCommit;
+exports.checkWorkingTreeClean = checkWorkingTreeClean;
+const git_js_1 = require("./git.js");
+function expectedBranchFor(ticket) {
+    if (ticket.work?.branch)
+        return ticket.work.branch;
+    if (ticket.relationships?.parent)
+        return `todo/${ticket.relationships.parent}`;
+    return `todo/${ticket.id}`;
+}
+function checkOnExpectedBranch(ticket, currentBranch) {
+    const expected = expectedBranchFor(ticket);
+    if (currentBranch === expected)
+        return { ok: true };
+    return {
+        ok: false,
+        message: `Refusing to close ${ticket.id}: HEAD is on '${currentBranch}', expected '${expected}'.\n` +
+            `  Run \`todo work ${ticket.id}\` to switch to the right branch, ` +
+            `or pass --force to override.`,
+    };
+}
+function checkBranchHasTodoCommit(ticket, repoRoot, commitPrefix) {
+    const base = ticket.work?.base_branch ?? (0, git_js_1.getDefaultBranch)(repoRoot);
+    const messages = (0, git_js_1.getCommitMessagesBetween)(base, "HEAD", repoRoot);
+    const needle = `${commitPrefix}${ticket.id}`;
+    const found = messages.some((m) => m.includes(needle));
+    if (found)
+        return { ok: true };
+    return {
+        ok: false,
+        message: `Refusing to close ${ticket.id}: no commit since ${base} has message containing '${needle}'.\n` +
+            `  Either amend a commit to include the prefix, or pass --force ` +
+            `if this ticket genuinely has no code change attached.`,
+    };
+}
+function checkWorkingTreeClean(repoRoot) {
+    if (!(0, git_js_1.hasUncommittedChanges)(repoRoot))
+        return { ok: true };
+    return {
+        ok: false,
+        message: "Refusing to switch branches: working tree has uncommitted changes.\n" +
+            "  Commit, stash, or discard them first.",
+    };
+}

package/dist/cli.js

@@ -8,12 +8,14 @@ const dedup_js_1 = require("./commands/dedup.js");
 const edit_js_1 = require("./commands/edit.js");
 const export_js_1 = require("./commands/export.js");
 const init_js_1 = require("./commands/init.js");
+const install_hooks_js_1 = require("./commands/install-hooks.js");
 const link_js_1 = require("./commands/link.js");
 const list_js_1 = require("./commands/list.js");
 const new_js_1 = require("./commands/new.js");
 const next_js_1 = require("./commands/next.js");
 const scan_js_1 = require("./commands/scan.js");
 const show_js_1 = require("./commands/show.js");
+const sync_js_1 = require("./commands/sync.js");
 const transition_js_1 = require("./commands/transition.js");
 const work_js_1 = require("./commands/work.js");
 const program = new commander_1.Command();
@@ -35,4 +37,6 @@ program
 (0, link_js_1.registerLink)(program);
 (0, scan_js_1.registerScan)(program);
 (0, dedup_js_1.registerDedup)(program);
+(0, install_hooks_js_1.registerInstallHooks)(program);
+(0, sync_js_1.registerSync)(program);
 program.parse(process.argv);

package/dist/commands/close.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerClose = registerClose;
+const branch_guard_js_1 = require("../branch-guard.js");
+const config_js_1 = require("../config.js");
 const context_js_1 = require("../context.js");
 const errors_js_1 = require("../errors.js");
 const git_js_1 = require("../git.js");
@@ -14,11 +16,35 @@ function registerClose(program) {
         .option("--test <file::func>", "test file and function (colon-separated)")
         .option("--note <text>", "resolution note")
         .option("--checkout", "git checkout base_branch after closing")
+        .option("--force", "skip branch and commit-message guards")
         .action((id, opts) => {
         const ctx = (0, context_js_1.getContext)(true);
-        const { repoRoot } = ctx;
+        const { repoRoot, config } = ctx;
         try {
             const ticket = (0, ticket_js_1.readTicketByPrefix)(repoRoot, id);
+            // Branch-convention guards (skippable with --force).
+            if (!opts.force) {
+                let currentBranch = "";
+                try {
+                    currentBranch = (0, git_js_1.getCurrentBranch)(repoRoot);
+                }
+                catch {
+                    // Detached HEAD or other; treat as a branch mismatch.
+                }
+                const branchCheck = (0, branch_guard_js_1.checkOnExpectedBranch)(ticket, currentBranch);
+                if (!branchCheck.ok) {
+                    console.error(`Error: ${branchCheck.message}`);
+                    process.exit(1);
+                }
+                const commitCheck = (0, branch_guard_js_1.checkBranchHasTodoCommit)(ticket, repoRoot, (0, config_js_1.getCommitPrefix)(config));
+                if (!commitCheck.ok) {
+                    console.error(`Error: ${commitCheck.message}`);
+                    process.exit(1);
+                }
+            }
+            else {
+                console.error("Warning: --force used; skipping branch guards.");
+            }
             // Resolve commit
             let commit;
             if (opts.commit) {

package/dist/commands/install-hooks.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInstallHooks(program: Command): void;

package/dist/commands/install-hooks.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInstallHooks = registerInstallHooks;
+const config_js_1 = require("../config.js");
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const hooks_js_1 = require("../hooks.js");
+function reportInstall(name, res) {
+    if (res.action === "refused") {
+        console.error(`Error: ${res.reason}`);
+        return false;
+    }
+    console.log(`${name}: ${res.action} ${res.path}`);
+    return true;
+}
+function reportUninstall(name, res) {
+    if (res.action === "refused") {
+        console.error(`Error: ${res.reason}`);
+        return false;
+    }
+    console.log(res.reason
+        ? `${name}: ${res.reason} (${res.path})`
+        : `${name}: removed ${res.path}`);
+    return true;
+}
+function selectHooks(opts) {
+    if (opts.onlySync)
+        return ["post-commit"];
+    if (opts.withSync)
+        return ["prepare-commit-msg", "post-commit"];
+    return ["prepare-commit-msg"];
+}
+function renderHook(name, config) {
+    if (name === "prepare-commit-msg") {
+        return (0, hooks_js_1.renderPrepareCommitMsg)((0, config_js_1.getCommitPrefix)(config));
+    }
+    return (0, hooks_js_1.renderPostCommit)();
+}
+function registerInstallHooks(program) {
+    program
+        .command("install-hooks")
+        .description("Install git hooks enforcing todo conventions (prepare-commit-msg, optionally post-commit auto-sync)")
+        .option("--force", "overwrite hooks not managed by todo")
+        .option("--uninstall", "remove managed hooks instead of installing")
+        .option("--with-sync", "also install the post-commit hook that runs `todo sync --quiet` after each commit")
+        .option("--only-sync", "install or uninstall only the post-commit auto-sync hook (skip prepare-commit-msg)")
+        .action((opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot, config } = ctx;
+        try {
+            const hooks = selectHooks(opts);
+            let failed = false;
+            for (const name of hooks) {
+                if (opts.uninstall) {
+                    const res = (0, hooks_js_1.uninstallHook)(repoRoot, name, {
+                        force: !!opts.force,
+                    });
+                    if (!reportUninstall(name, res))
+                        failed = true;
+                }
+                else {
+                    const content = renderHook(name, config);
+                    const res = (0, hooks_js_1.installHook)(repoRoot, name, content, {
+                        force: !!opts.force,
+                    });
+                    if (!reportInstall(name, res))
+                        failed = true;
+                }
+            }
+            if (failed)
+                process.exit(1);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerSync(program: Command): void;

package/dist/commands/sync.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSync = registerSync;
+const context_js_1 = require("../context.js");
+const errors_js_1 = require("../errors.js");
+const hermes_js_1 = require("../hermes.js");
+const ticket_js_1 = require("../ticket.js");
+function summariseAction(a) {
+    if (a.kind === "create") {
+        return `+ create ${a.ticket.id} (${a.ticket.state}) → ${a.targetStatus}`;
+    }
+    if (a.kind === "update") {
+        return `~ update ${a.ticket.id} ${a.fromStatus} → ${a.toStatus}`;
+    }
+    if (a.kind === "noop") {
+        return `= ${a.ticket.id} unchanged (${a.status})`;
+    }
+    return `! skip ${a.ticket.id}: ${a.reason}`;
+}
+function registerSync(program) {
+    program
+        .command("sync")
+        .description("Push ticket state to a Hermes Kanban board")
+        .option("--dry-run", "show what would change without contacting Hermes")
+        .option("--quiet", "only print errors")
+        .option("--board <slug>", "override the configured board slug")
+        .action(async (opts) => {
+        const ctx = (0, context_js_1.getContext)(true);
+        const { repoRoot, config } = ctx;
+        try {
+            const resolved = (0, hermes_js_1.resolveHermesConfig)(config.hermes, process.env, opts.board);
+            if ("error" in resolved) {
+                console.error(`Error: ${resolved.error}`);
+                process.exit(1);
+            }
+            const open = (0, ticket_js_1.listTickets)(repoRoot, "open");
+            const done = (0, ticket_js_1.listTickets)(repoRoot, "done");
+            const tickets = [...open, ...done];
+            const client = (0, hermes_js_1.makeKanbanClient)(resolved);
+            const existingByHermesId = new Map();
+            if (!opts.dryRun) {
+                const board = await client.getBoard();
+                for (const col of board.columns) {
+                    for (const task of col.tasks) {
+                        // Tasks come back with their per-column status; trust it.
+                        existingByHermesId.set(task.id, { ...task, status: col.name });
+                    }
+                }
+            }
+            else {
+                // In dry-run we can't reach the server; treat ids we have cached
+                // in tickets as existing (best-effort preview only).
+                for (const t of tickets) {
+                    const hid = t.external_refs?.hermes_task_id;
+                    if (hid) {
+                        existingByHermesId.set(hid, {
+                            id: hid,
+                            title: t.summary,
+                            status: "?",
+                        });
+                    }
+                }
+            }
+            const actions = (0, hermes_js_1.planSyncActions)(tickets, existingByHermesId);
+            if (!opts.quiet) {
+                for (const a of actions)
+                    console.log(summariseAction(a));
+            }
+            if (opts.dryRun) {
+                if (!opts.quiet)
+                    console.log("(dry run — no requests made)");
+                return;
+            }
+            const stats = await (0, hermes_js_1.applySyncActions)(actions, client, (ticket, hermesId) => {
+                const refs = ticket.external_refs ?? {};
+                refs.hermes_task_id = hermesId;
+                refs.hermes_board = resolved.board;
+                ticket.external_refs = refs;
+                ticket.updated_at = new Date().toISOString();
+                (0, ticket_js_1.writeTicket)(repoRoot, ticket);
+            });
+            if (!opts.quiet) {
+                console.log(`done: ${stats.created} created, ${stats.updated} updated, ` +
+                    `${stats.noop} unchanged, ${stats.skipped} skipped`);
+            }
+            // fetch keep-alive sockets can hold the event loop open for ~30s
+            // past completion; for a CLI we want a snappy exit.
+            process.exit(0);
+        }
+        catch (err) {
+            (0, errors_js_1.handleError)(err);
+        }
+    });
+}

package/dist/commands/work.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerWork = registerWork;
+const branch_guard_js_1 = require("../branch-guard.js");
 const context_js_1 = require("../context.js");
 const errors_js_1 = require("../errors.js");
 const git_js_1 = require("../git.js");
@@ -51,6 +52,27 @@ function registerWork(program) {
                 }
             }
             const defaultBranch = (0, git_js_1.getDefaultBranch)(repoRoot);
+            // Dirty-tree guard: refuse to leave a different todo/* branch
+            // with uncommitted work. We let `main`/other branches through —
+            // only the cross-ticket case is the one that loses work.
+            if (!opts.skipBranch) {
+                let currentBranch = "";
+                try {
+                    currentBranch = (0, git_js_1.getCurrentBranch)(repoRoot);
+                }
+                catch {
+                    currentBranch = "";
+                }
+                const onDifferentTodoBranch = currentBranch.startsWith("todo/") && currentBranch !== branch;
+                if (onDifferentTodoBranch) {
+                    const clean = (0, branch_guard_js_1.checkWorkingTreeClean)(repoRoot);
+                    if (!clean.ok) {
+                        console.error(`Error: ${clean.message}\n  You are on ${currentBranch}; ` +
+                            `target branch is ${branch}.`);
+                        process.exit(1);
+                    }
+                }
+            }
             if (opts.skipBranch) {
                 // --no-branch: orchestrator mode — activate on current branch without any git ops
                 const currentBranch = (0, git_js_1.getCurrentBranch)(repoRoot);

package/dist/git.d.ts

@@ -17,3 +17,6 @@ export declare function getLastCommitForFile(path: string, cwd?: string): string
 export declare function createBranch(name: string, cwd?: string): void;
 export declare function checkoutBranch(name: string, cwd?: string): void;
 export declare function getGitUserName(cwd?: string): string;
+export declare function hasUncommittedChanges(cwd?: string): boolean;
+export declare function getCommitMessagesBetween(base: string, head: string, cwd?: string): string[];
+export declare function getGitDir(cwd?: string): string;

package/dist/git.js

@@ -17,6 +17,9 @@ exports.getLastCommitForFile = getLastCommitForFile;
 exports.createBranch = createBranch;
 exports.checkoutBranch = checkoutBranch;
 exports.getGitUserName = getGitUserName;
+exports.hasUncommittedChanges = hasUncommittedChanges;
+exports.getCommitMessagesBetween = getCommitMessagesBetween;
+exports.getGitDir = getGitDir;
 const node_child_process_1 = require("node:child_process");
 class GitError extends Error {
     cause;
@@ -117,3 +120,24 @@ function checkoutBranch(name, cwd = process.cwd()) {
 function getGitUserName(cwd = process.cwd()) {
     return exec(["config", "user.name"], cwd);
 }
+function hasUncommittedChanges(cwd = process.cwd()) {
+    const out = exec(["status", "--porcelain"], cwd);
+    return out.length > 0;
+}
+function getCommitMessagesBetween(base, head, cwd = process.cwd()) {
+    try {
+        const out = exec(["log", `${base}..${head}`, "--format=%s%n%b%n--END--"], cwd);
+        if (!out)
+            return [];
+        return out
+            .split("\n--END--")
+            .map((s) => s.trim())
+            .filter((s) => s.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function getGitDir(cwd = process.cwd()) {
+    return exec(["rev-parse", "--git-dir"], cwd);
+}

package/dist/hermes.d.ts

@@ -0,0 +1,59 @@
+import type { HermesConfig, State, Ticket } from "./types.js";
+export declare const STATE_TO_KANBAN: Record<State, string>;
+export interface ResolvedHermesConfig {
+    dashboard_url: string;
+    board: string;
+    session_token: string;
+}
+export declare function resolveHermesConfig(cfg: HermesConfig | undefined, env?: NodeJS.ProcessEnv, boardOverride?: string): ResolvedHermesConfig | {
+    error: string;
+};
+export interface KanbanTask {
+    id: string;
+    title: string;
+    status: string;
+    body?: string;
+}
+export interface KanbanClient {
+    getBoard(): Promise<{
+        columns: {
+            name: string;
+            tasks: KanbanTask[];
+        }[];
+    }>;
+    getTask(id: string): Promise<KanbanTask | null>;
+    createTask(payload: {
+        title: string;
+        body?: string;
+        idempotency_key?: string;
+    }): Promise<KanbanTask>;
+    updateStatus(id: string, status: string): Promise<KanbanTask>;
+}
+export declare function makeKanbanClient(cfg: ResolvedHermesConfig, fetchImpl?: typeof fetch): KanbanClient;
+export type SyncAction = {
+    kind: "create";
+    ticket: Ticket;
+    targetStatus: string;
+} | {
+    kind: "update";
+    ticket: Ticket;
+    hermesId: string;
+    fromStatus: string;
+    toStatus: string;
+} | {
+    kind: "noop";
+    ticket: Ticket;
+    hermesId: string;
+    status: string;
+} | {
+    kind: "skip";
+    ticket: Ticket;
+    reason: string;
+};
+export declare function planSyncActions(tickets: Ticket[], existingByHermesId: Map<string, KanbanTask>): SyncAction[];
+export declare function applySyncActions(actions: SyncAction[], client: KanbanClient, onPersistId: (ticket: Ticket, hermesId: string) => void): Promise<{
+    created: number;
+    updated: number;
+    skipped: number;
+    noop: number;
+}>;

package/dist/hermes.js

@@ -0,0 +1,165 @@
+"use strict";
+// Hermes Kanban push-sync client.
+//
+// .todo/ remains the source of truth; this module only pushes state out
+// to a Hermes dashboard's Kanban plugin API at /api/plugins/kanban/.
+// We persist the Hermes task id on each ticket under
+// ``external_refs.hermes_task_id`` so re-syncs hit the same card.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATE_TO_KANBAN = void 0;
+exports.resolveHermesConfig = resolveHermesConfig;
+exports.makeKanbanClient = makeKanbanClient;
+exports.planSyncActions = planSyncActions;
+exports.applySyncActions = applySyncActions;
+exports.STATE_TO_KANBAN = {
+    open: "todo",
+    active: "running",
+    blocked: "blocked",
+    done: "done",
+    wontfix: "archived",
+    duplicate: "archived",
+};
+function resolveHermesConfig(cfg, env = process.env, boardOverride) {
+    if (!cfg) {
+        return {
+            error: "Hermes config missing. Add a `hermes` block to .todo/config.json:\n" +
+                '  { "hermes": { "dashboard_url": "http://localhost:8765", ' +
+                '"board": "<slug>", "session_token": "<token>" } }\n' +
+                "  session_token can also come from HERMES_SESSION_TOKEN env.",
+        };
+    }
+    const dashboard_url = cfg.dashboard_url?.replace(/\/$/, "");
+    const board = boardOverride ?? cfg.board;
+    const session_token = cfg.session_token ?? env["HERMES_SESSION_TOKEN"];
+    if (!dashboard_url)
+        return { error: "Hermes config missing dashboard_url." };
+    if (!board)
+        return { error: "Hermes config missing board." };
+    if (!session_token) {
+        return {
+            error: "Hermes session token missing. Set hermes.session_token in " +
+                ".todo/config.json or HERMES_SESSION_TOKEN in the environment.",
+        };
+    }
+    return { dashboard_url, board, session_token };
+}
+function makeKanbanClient(cfg, fetchImpl = fetch) {
+    const headers = {
+        Authorization: `Bearer ${cfg.session_token}`,
+        "Content-Type": "application/json",
+    };
+    const base = `${cfg.dashboard_url}/api/plugins/kanban`;
+    const boardQ = `?board=${encodeURIComponent(cfg.board)}`;
+    async function expectJson(res) {
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Hermes ${res.status} ${res.statusText}: ${text || "(no body)"}`);
+        }
+        return res.json();
+    }
+    return {
+        async getBoard() {
+            const res = await fetchImpl(`${base}/board${boardQ}`, { headers });
+            return (await expectJson(res));
+        },
+        async getTask(id) {
+            const res = await fetchImpl(`${base}/tasks/${id}${boardQ}`, { headers });
+            if (res.status === 404)
+                return null;
+            const body = (await expectJson(res));
+            return body.task;
+        },
+        async createTask(payload) {
+            const res = await fetchImpl(`${base}/tasks${boardQ}`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(payload),
+            });
+            const body = (await expectJson(res));
+            return body.task;
+        },
+        async updateStatus(id, status) {
+            const res = await fetchImpl(`${base}/tasks/${id}${boardQ}`, {
+                method: "PATCH",
+                headers,
+                body: JSON.stringify({ status }),
+            });
+            const body = (await expectJson(res));
+            return body.task;
+        },
+    };
+}
+function planSyncActions(tickets, existingByHermesId) {
+    const actions = [];
+    for (const t of tickets) {
+        const targetStatus = exports.STATE_TO_KANBAN[t.state];
+        if (!targetStatus) {
+            actions.push({
+                kind: "skip",
+                ticket: t,
+                reason: `no kanban mapping for state '${t.state}'`,
+            });
+            continue;
+        }
+        const hermesId = t.external_refs?.hermes_task_id;
+        if (!hermesId) {
+            actions.push({ kind: "create", ticket: t, targetStatus });
+            continue;
+        }
+        const existing = existingByHermesId.get(hermesId);
+        if (!existing) {
+            // Cached id no longer exists on the board; re-create.
+            actions.push({ kind: "create", ticket: t, targetStatus });
+            continue;
+        }
+        if (existing.status === targetStatus) {
+            actions.push({
+                kind: "noop",
+                ticket: t,
+                hermesId,
+                status: targetStatus,
+            });
+        }
+        else {
+            actions.push({
+                kind: "update",
+                ticket: t,
+                hermesId,
+                fromStatus: existing.status,
+                toStatus: targetStatus,
+            });
+        }
+    }
+    return actions;
+}
+async function applySyncActions(actions, client, onPersistId) {
+    let created = 0;
+    let updated = 0;
+    let skipped = 0;
+    let noop = 0;
+    for (const a of actions) {
+        if (a.kind === "create") {
+            const task = await client.createTask({
+                title: a.ticket.summary,
+                body: a.ticket.description,
+                idempotency_key: a.ticket.id,
+            });
+            onPersistId(a.ticket, task.id);
+            if (task.status !== a.targetStatus) {
+                await client.updateStatus(task.id, a.targetStatus);
+            }
+            created++;
+        }
+        else if (a.kind === "update") {
+            await client.updateStatus(a.hermesId, a.toStatus);
+            updated++;
+        }
+        else if (a.kind === "noop") {
+            noop++;
+        }
+        else {
+            skipped++;
+        }
+    }
+    return { created, updated, skipped, noop };
+}

package/dist/hooks.d.ts

@@ -0,0 +1,23 @@
+export type HookName = "prepare-commit-msg" | "post-commit";
+export declare const SENTINEL_PREFIX = "# @todo-managed-hook";
+export declare function hookSentinel(name: HookName, version: number): string;
+export declare function renderPrepareCommitMsg(commitPrefix: string): string;
+export declare function renderPostCommit(): string;
+export interface HookStatus {
+    exists: boolean;
+    managed: boolean;
+    path: string;
+}
+export declare function hookPath(repoRoot: string, name: HookName): string;
+export declare function readHookStatus(repoRoot: string, name: HookName): HookStatus;
+export interface InstallResult {
+    action: "created" | "replaced" | "refused" | "removed";
+    path: string;
+    reason?: string;
+}
+export declare function installHook(repoRoot: string, name: HookName, content: string, opts?: {
+    force?: boolean;
+}): InstallResult;
+export declare function uninstallHook(repoRoot: string, name: HookName, opts?: {
+    force?: boolean;
+}): InstallResult;