@fluado/enmetu 0.0.0-stage → 0.2.0

package/dist/adapters/git/gitLocatorFacade.d.ts

@@ -0,0 +1,8 @@
+import type { GitRunnerFactory } from '../../contracts/IGitRunner.js';
+import type { IRepositoryLocator, RepositoryLocation } from '../../contracts/IRepositoryLocator.js';
+/** Facade: resolves the repository from a start directory through git, before the root is known (D9). */
+export declare class GitLocatorFacade implements IRepositoryLocator {
+    private readonly createRunner;
+    constructor(createRunner: GitRunnerFactory);
+    locate(startDir: string): Promise<RepositoryLocation>;
+}

package/dist/adapters/git/gitLocatorFacade.js

@@ -0,0 +1,75 @@
+import { join } from 'node:path';
+import { GitCommandError, GitOutputError, PreflightError, } from '../../contracts/errors.js';
+import { parseGitVersion, parseRevParsePaths, } from '../../core/git/porcelain.js';
+const NOT_A_REPOSITORY_EXIT = 128;
+/** Facade: resolves the repository from a start directory through git, before the root is known (D9). */
+export class GitLocatorFacade {
+    createRunner;
+    constructor(createRunner) {
+        this.createRunner = createRunner;
+    }
+    async locate(startDir) {
+        const runner = this.createRunner(startDir);
+        const versionText = (await runOk(runner, ['version'])).stdout.toString('utf8');
+        const version = parseGitVersion(versionText);
+        if (version === null) {
+            throw new GitOutputError(`unexpected git version output: ${JSON.stringify(versionText.trim().slice(0, 120))}`);
+        }
+        const kindArgs = [
+            'rev-parse',
+            '--is-bare-repository',
+            '--is-inside-work-tree',
+        ];
+        const kind = await runner.run(kindArgs);
+        if (kind.exitCode === NOT_A_REPOSITORY_EXIT) {
+            return { kind: 'not-a-repository' };
+        }
+        if (kind.exitCode !== 0) {
+            throw gitFailed(kindArgs, kind);
+        }
+        const [bare, insideWorkTree] = kind.stdout.toString('utf8').split('\n');
+        if (bare === 'true') {
+            return { kind: 'bare' };
+        }
+        // Inside the .git directory of a repository with a work tree: there is
+        // no tree to keep committed from here.
+        if (insideWorkTree !== 'true') {
+            return { kind: 'not-a-repository' };
+        }
+        // Not --git-path hooks: it honours core.hooksPath, and git refuses an
+        // empty one as a path (exit 128) although it runs hooks with it; the
+        // installer writes only to the repository's own hooks directory, and only
+        // while core.hooksPath is unset (design 14.17).
+        const paths = parseRevParsePaths((await runOk(runner, [
+            'rev-parse',
+            '--path-format=absolute',
+            '--show-toplevel',
+            '--git-dir',
+            '--git-common-dir',
+        ])).stdout.toString('utf8'));
+        if (paths === null) {
+            throw new PreflightError('a repository path contains a newline, which enmetu does not support', 'PATH_UNSUPPORTED');
+        }
+        return {
+            kind: 'found',
+            paths: {
+                root: paths.root,
+                gitDir: paths.gitDir,
+                hooksDir: join(paths.commonDir, 'hooks'),
+                stateDir: join(paths.gitDir, 'enmetu'),
+            },
+            version,
+        };
+    }
+}
+async function runOk(runner, args) {
+    const result = await runner.run(args);
+    if (result.exitCode !== 0) {
+        throw gitFailed(args, result);
+    }
+    return result;
+}
+function gitFailed(args, result) {
+    const firstLine = result.stderr.split('\n')[0] ?? '';
+    return new GitCommandError(`git ${args.join(' ')} exited ${result.exitCode}: ${firstLine}`, 'GIT_FAILED', args, result.exitCode, result.stderr);
+}

package/dist/adapters/git/gitProcessAdapter.d.ts

@@ -0,0 +1,46 @@
+import type { GitRunOptions, GitRunResult, IGitRunner } from '../../contracts/IGitRunner.js';
+/** 128 MiB: a cat-file batch chunk (64 MiB of content) plus headers fits with room. */
+export declare const GIT_MAX_BUFFER_BYTES = 134217728;
+export interface GitProcessAdapterOptions {
+    readonly cwd: string;
+    /** The environment git children start from (Runtime.env); the adapter reads no global environment. */
+    readonly baseEnv: Readonly<Record<string, string | undefined>>;
+    readonly timeoutMs: number;
+    readonly gitBinary: string;
+    /**
+     * The commit index (design 12.7): every child gets GIT_INDEX_FILE=<indexFile>
+     * and the one-invocation options -c core.splitIndex=false -c
+     * core.fsmonitor=false before the facade's arguments, so the commit index is
+     * one self-contained file and no fsmonitor hook runs for it.
+     */
+    readonly indexFile?: string | undefined;
+}
+/**
+ * Adapter: the only file that spawns git (execFile with an argument array and
+ * encoding 'buffer'). Adds GIT_TERMINAL_PROMPT=0, GIT_OPTIONAL_LOCKS=0 and
+ * LC_ALL=C to the base environment of every child.
+ */
+export declare class GitProcessAdapter implements IGitRunner {
+    private readonly options;
+    private readonly env;
+    constructor(options: GitProcessAdapterOptions);
+    /**
+     * options.timeoutMs replaces the adapter's timeout for this call;
+     * options.outputCapBytes keeps the first bytes of stdout and of stderr and
+     * drops the rest without failing (design 12.7, Decision 83), where without it
+     * output beyond GIT_MAX_BUFFER_BYTES fails the call. options.reflogAction
+     * sets GIT_REFLOG_ACTION for this one child only (design 13.2).
+     */
+    run(args: readonly string[], options?: GitRunOptions): Promise<GitRunResult>;
+    /**
+     * A call with its own budget (a repository hook, design 12.7, Decision 83):
+     * git leads a new process group, so the timeout ends git and everything it
+     * started (SIGTERM, then SIGKILL after GROUP_KILL_GRACE_MS); killing `git
+     * hook run` alone would leave the hook running. Output beyond the cap is
+     * read and dropped, so a loud hook neither blocks on a full pipe nor fails.
+     * The timers are AbortSignal timers of this one child, like execFile's own
+     * timeout option on the default path: process plumbing, not scheduling.
+     */
+    private runInGroup;
+    private failure;
+}

package/dist/adapters/git/gitProcessAdapter.js

@@ -0,0 +1,261 @@
+import { execFile, spawn } from 'node:child_process';
+import { kill } from 'node:process';
+import { GitCommandError } from '../../contracts/errors.js';
+/** 128 MiB: a cat-file batch chunk (64 MiB of content) plus headers fits with room. */
+export const GIT_MAX_BUFFER_BYTES = 134217728;
+const KILL_SIGNAL = 'SIGTERM';
+const MAX_BUFFER_EXCEEDED = 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
+/** After a group's SIGTERM, how long its processes get before SIGKILL (Decision 83). */
+const GROUP_KILL_GRACE_MS = 2000;
+/** The commit index is one self-contained file and runs no fsmonitor hook (design 12.7). */
+const COMMIT_INDEX_ARGS = [
+    '-c',
+    'core.splitIndex=false',
+    '-c',
+    'core.fsmonitor=false',
+];
+/**
+ * Adapter: the only file that spawns git (execFile with an argument array and
+ * encoding 'buffer'). Adds GIT_TERMINAL_PROMPT=0, GIT_OPTIONAL_LOCKS=0 and
+ * LC_ALL=C to the base environment of every child.
+ */
+export class GitProcessAdapter {
+    options;
+    env;
+    constructor(options) {
+        this.options = options;
+        this.env = childEnvironment(options.baseEnv, options.indexFile);
+    }
+    /**
+     * options.timeoutMs replaces the adapter's timeout for this call;
+     * options.outputCapBytes keeps the first bytes of stdout and of stderr and
+     * drops the rest without failing (design 12.7, Decision 83), where without it
+     * output beyond GIT_MAX_BUFFER_BYTES fails the call. options.reflogAction
+     * sets GIT_REFLOG_ACTION for this one child only (design 13.2).
+     */
+    run(args, options) {
+        const argv = this.options.indexFile === undefined
+            ? args
+            : [...COMMIT_INDEX_ARGS, ...args];
+        const env = callEnvironment(this.env, options?.reflogAction);
+        if (options?.timeoutMs !== undefined ||
+            options?.outputCapBytes !== undefined ||
+            options?.abort !== undefined) {
+            return this.runInGroup(argv, env, options);
+        }
+        return new Promise((resolve, reject) => {
+            const child = execFile(this.options.gitBinary, argv, {
+                cwd: this.options.cwd,
+                env,
+                encoding: 'buffer',
+                maxBuffer: GIT_MAX_BUFFER_BYTES,
+                timeout: this.options.timeoutMs,
+                killSignal: KILL_SIGNAL,
+                windowsHide: true,
+            }, (error, stdout, stderr) => {
+                const stderrText = stderr.toString('utf8');
+                if (error === null) {
+                    resolve({ exitCode: 0, stdout, stderr: stderrText });
+                    return;
+                }
+                if (typeof error.code === 'number') {
+                    resolve({ exitCode: error.code, stdout, stderr: stderrText });
+                    return;
+                }
+                reject(this.failure(error, argv, stderrText));
+            });
+            // git may exit before reading all of stdin (a fatal error on the first
+            // line); the resulting EPIPE must not become an uncaught exception.
+            child.stdin?.on('error', () => undefined);
+            // Closing stdin even without input, so a command that reads it
+            // (cat-file --batch, --pathspec-from-file=-) sees EOF instead of hanging.
+            child.stdin?.end(options?.stdin ?? '');
+        });
+    }
+    /**
+     * A call with its own budget (a repository hook, design 12.7, Decision 83):
+     * git leads a new process group, so the timeout ends git and everything it
+     * started (SIGTERM, then SIGKILL after GROUP_KILL_GRACE_MS); killing `git
+     * hook run` alone would leave the hook running. Output beyond the cap is
+     * read and dropped, so a loud hook neither blocks on a full pipe nor fails.
+     * The timers are AbortSignal timers of this one child, like execFile's own
+     * timeout option on the default path: process plumbing, not scheduling.
+     */
+    runInGroup(argv, env, options) {
+        const timeoutMs = options.timeoutMs ?? this.options.timeoutMs;
+        const cap = options.outputCapBytes;
+        const abort = options.abort;
+        const command = `git ${argv.join(' ')}`;
+        const abortedError = (stderrText) => new GitCommandError(`${command} was ended because enmetu is stopping`, 'GIT_ABORTED', argv, null, stderrText);
+        if (abort?.aborted === true) {
+            return Promise.reject(abortedError(''));
+        }
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.options.gitBinary, argv, {
+                cwd: this.options.cwd,
+                env,
+                detached: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                windowsHide: true,
+            });
+            const stdout = new CappedOutput(cap ?? GIT_MAX_BUFFER_BYTES);
+            const stderr = new CappedOutput(cap ?? GIT_MAX_BUFFER_BYTES);
+            let settled = false;
+            let ended = null;
+            const deadline = AbortSignal.timeout(timeoutMs);
+            let grace = null;
+            const settle = (outcome) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                deadline.removeEventListener('abort', onDeadline);
+                abort?.removeEventListener('abort', onAbort);
+                grace?.removeEventListener('abort', onGrace);
+                outcome();
+            };
+            const endedError = () => ended === 'aborted'
+                ? abortedError(stderr.text())
+                : new GitCommandError(`${command} timed out after ${timeoutMs} ms`, 'GIT_TIMEOUT', argv, null, stderr.text());
+            const onGrace = () => {
+                killGroup(child.pid, 'SIGKILL');
+                // A process that left the group (setsid) may still hold the pipes
+                // open; the call ends here regardless.
+                child.stdout.destroy();
+                child.stderr.destroy();
+                settle(() => reject(endedError()));
+            };
+            const endGroup = (reason) => {
+                if (ended !== null) {
+                    return;
+                }
+                ended = reason;
+                killGroup(child.pid, KILL_SIGNAL);
+                grace = AbortSignal.timeout(GROUP_KILL_GRACE_MS);
+                grace.addEventListener('abort', onGrace, { once: true });
+            };
+            const onDeadline = () => endGroup('timeout');
+            const onAbort = () => endGroup('aborted');
+            deadline.addEventListener('abort', onDeadline, { once: true });
+            abort?.addEventListener('abort', onAbort, { once: true });
+            child.stdout.on('data', (chunk) => stdout.add(chunk));
+            child.stderr.on('data', (chunk) => stderr.add(chunk));
+            child.on('error', (error) => {
+                settle(() => reject(new GitCommandError(`git could not be started: binary '${this.options.gitBinary}', directory '${this.options.cwd}' (${errorCode(error)})`, 'GIT_NOT_FOUND', argv, null, '')));
+            });
+            child.on('close', (code, signal) => {
+                if (ended !== null) {
+                    settle(() => reject(endedError()));
+                    return;
+                }
+                if (cap === undefined && (stdout.dropped || stderr.dropped)) {
+                    killGroup(child.pid, 'SIGKILL');
+                    settle(() => reject(new GitCommandError(`${command} wrote more than ${GIT_MAX_BUFFER_BYTES} bytes`, 'GIT_FAILED', argv, null, stderr.text())));
+                    return;
+                }
+                if (code !== null) {
+                    settle(() => resolve({
+                        exitCode: code,
+                        stdout: stdout.bytes(),
+                        stderr: stderr.text(),
+                    }));
+                    return;
+                }
+                settle(() => reject(new GitCommandError(`${command} ended by signal ${signal ?? 'unknown'}`, 'GIT_FAILED', argv, null, stderr.text())));
+            });
+            child.stdin.on('error', () => undefined);
+            child.stdin.end(options.stdin ?? '');
+        });
+    }
+    failure(error, args, stderr) {
+        const command = `git ${args.join(' ')}`;
+        if (error.code === MAX_BUFFER_EXCEEDED) {
+            return new GitCommandError(`${command} wrote more than ${GIT_MAX_BUFFER_BYTES} bytes`, 'GIT_FAILED', args, null, stderr);
+        }
+        if (error.killed === true && error.signal === KILL_SIGNAL) {
+            return new GitCommandError(`${command} timed out after ${this.options.timeoutMs} ms`, 'GIT_TIMEOUT', args, null, stderr);
+        }
+        if (typeof error.code === 'string') {
+            return new GitCommandError(
+            // Node reports a missing binary and a missing working directory with
+            // the same ENOENT, so the message names both.
+            `git could not be started: binary '${this.options.gitBinary}', directory '${this.options.cwd}' (${error.code})`, 'GIT_NOT_FOUND', args, null, stderr);
+        }
+        return new GitCommandError(`${command} ended by signal ${error.signal ?? 'unknown'}`, 'GIT_FAILED', args, null, stderr);
+    }
+}
+/** Keeps the first `cap` bytes of a stream and counts that more arrived. */
+class CappedOutput {
+    cap;
+    chunks = [];
+    length = 0;
+    dropped = false;
+    constructor(cap) {
+        this.cap = cap;
+    }
+    add(chunk) {
+        const room = this.cap - this.length;
+        if (room <= 0) {
+            this.dropped = this.dropped || chunk.length > 0;
+            return;
+        }
+        const kept = chunk.length > room ? chunk.subarray(0, room) : chunk;
+        this.dropped = this.dropped || kept.length < chunk.length;
+        this.chunks.push(kept);
+        this.length += kept.length;
+    }
+    bytes() {
+        return Buffer.concat(this.chunks);
+    }
+    text() {
+        return this.bytes().toString('utf8');
+    }
+}
+/** Signals git's whole process group; a group that is already gone is fine. */
+function killGroup(pid, signal) {
+    if (pid === undefined) {
+        return;
+    }
+    try {
+        kill(-pid, signal);
+    }
+    catch (error) {
+        if (errorCode(error) !== 'ESRCH') {
+            throw error;
+        }
+    }
+}
+function errorCode(error) {
+    if (typeof error === 'object' && error !== null && 'code' in error) {
+        return typeof error.code === 'string' ? error.code : 'unknown';
+    }
+    return 'unknown';
+}
+/**
+ * The adapter's environment, plus GIT_REFLOG_ACTION when the call names one.
+ * The shared environment is never changed, so no other call inherits it.
+ */
+function callEnvironment(env, reflogAction) {
+    if (reflogAction === undefined) {
+        return env;
+    }
+    return { ...env, GIT_REFLOG_ACTION: reflogAction };
+}
+function childEnvironment(baseEnv, indexFile) {
+    const env = {};
+    for (const [key, value] of Object.entries(baseEnv)) {
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    if (indexFile !== undefined) {
+        env.GIT_INDEX_FILE = indexFile;
+    }
+    // An https credential prompt fails instead of hanging the daemon.
+    env.GIT_TERMINAL_PROMPT = '0';
+    // git status takes no index.lock, so enmetu's reads never collide with a person's git.
+    env.GIT_OPTIONAL_LOCKS = '0';
+    // Stable English stderr for the two classifications the facade reads.
+    env.LC_ALL = 'C';
+    return env;
+}

package/dist/adapters/log/nullLogger.d.ts

@@ -0,0 +1,9 @@
+import type { ILogger, LogEntry } from '../../contracts/ILogger.js';
+/**
+ * Null Object for a step that must not log twice: the commit step's residue
+ * build repeats the guarded staging, whose EXCLUDED lines the first build
+ * already wrote (design 12.7). Built by the composition root only.
+ */
+export declare class NullLogger implements ILogger {
+    log(_entry: LogEntry): void;
+}

package/dist/adapters/log/nullLogger.js

@@ -0,0 +1,10 @@
+/**
+ * Null Object for a step that must not log twice: the commit step's residue
+ * build repeats the guarded staging, whose EXCLUDED lines the first build
+ * already wrote (design 12.7). Built by the composition root only.
+ */
+export class NullLogger {
+    log(_entry) {
+        // Deliberately empty: the entries were already logged by the first build.
+    }
+}

package/dist/adapters/log/stderrLoggerAdapter.d.ts

@@ -0,0 +1,10 @@
+import type { IClock } from '../../contracts/IClock.js';
+import type { ILogger, LogEntry } from '../../contracts/ILogger.js';
+import type { ITextSink } from '../../contracts/ITextSink.js';
+/** Adapter: one formatLogLine line plus a newline per entry, written to the injected sink. */
+export declare class StderrLoggerAdapter implements ILogger {
+    private readonly sink;
+    private readonly clock;
+    constructor(sink: ITextSink, clock: IClock);
+    log(entry: LogEntry): void;
+}

package/dist/adapters/log/stderrLoggerAdapter.js

@@ -0,0 +1,13 @@
+import { formatLogLine } from '../../core/log/formatLogLine.js';
+/** Adapter: one formatLogLine line plus a newline per entry, written to the injected sink. */
+export class StderrLoggerAdapter {
+    sink;
+    clock;
+    constructor(sink, clock) {
+        this.sink = sink;
+        this.clock = clock;
+    }
+    log(entry) {
+        this.sink.write(`${formatLogLine(entry, this.clock.now())}\n`);
+    }
+}

package/dist/adapters/process/nodeProcessAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { IProcessHost, StopSignal } from '../../contracts/IProcessHost.js';
+/** Adapter: process signals, kill(pid, 0) and os.hostname to IProcessHost. */
+export declare class NodeProcessAdapter implements IProcessHost {
+    get pid(): number;
+    get hostname(): string;
+    isAlive(pid: number): boolean;
+    onStopSignal(handler: (signal: StopSignal) => void): () => void;
+    exitNow(code: number): never;
+}

package/dist/adapters/process/nodeProcessAdapter.js

@@ -0,0 +1,56 @@
+import { hostname } from 'node:os';
+const STOP_SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+/** Adapter: process signals, kill(pid, 0) and os.hostname to IProcessHost. */
+export class NodeProcessAdapter {
+    get pid() {
+        return process.pid;
+    }
+    get hostname() {
+        return hostname();
+    }
+    isAlive(pid) {
+        // kill(0) and kill(-n) address process groups and would report a live
+        // group for a pid that names no process.
+        if (!Number.isInteger(pid) || pid <= 0) {
+            return false;
+        }
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            const code = errorCode(error);
+            if (code === 'ESRCH') {
+                return false;
+            }
+            // The process exists but belongs to another user.
+            if (code === 'EPERM') {
+                return true;
+            }
+            throw error;
+        }
+    }
+    onStopSignal(handler) {
+        const subscriptions = STOP_SIGNALS.map((signal) => {
+            const listener = () => handler(signal);
+            process.on(signal, listener);
+            return { signal, listener };
+        });
+        return () => {
+            for (const { signal, listener } of subscriptions) {
+                process.off(signal, listener);
+            }
+        };
+    }
+    exitNow(code) {
+        process.exit(code);
+    }
+}
+// Not instanceof Error: an error from Node's core can come from another realm
+// (Jest's test context), where instanceof is false.
+function errorCode(error) {
+    if (typeof error === 'object' && error !== null && 'code' in error) {
+        return typeof error.code === 'string' ? error.code : undefined;
+    }
+    return undefined;
+}

package/dist/adapters/watch/fsWatchAdapter.d.ts

@@ -0,0 +1,24 @@
+import type { IWatcher, WatchListener } from '../../contracts/IWatcher.js';
+/** The part of fs.FSWatcher the adapter uses. */
+export interface WatchHandle {
+    on(event: 'error', listener: (error: Error) => void): unknown;
+    close(): void;
+}
+/** A recursive watch of root that reports each event's root-relative filename (null when the platform gives none). */
+export type WatchFunction = (root: string, onEvent: (filename: string | null) => void) => WatchHandle;
+/** fs.watch(root, { recursive: true }), the production WatchFunction. */
+export declare const nodeWatch: WatchFunction;
+/**
+ * Adapter: fs.watch to IWatcher. Drops events isWatchNoise rejects, calls
+ * onChange() without a path for the rest, and reports the first watcher
+ * error through onFailure exactly once.
+ */
+export declare class FsWatchAdapter implements IWatcher {
+    private readonly root;
+    private readonly watchFunction;
+    private handle;
+    private failureReported;
+    constructor(root: string, watchFunction: WatchFunction);
+    start(listener: WatchListener): void;
+    close(): void;
+}

package/dist/adapters/watch/fsWatchAdapter.js

@@ -0,0 +1,47 @@
+import { watch } from 'node:fs';
+import { errorMessage } from '../../core/errors/errorMessage.js';
+import { isWatchNoise } from '../../core/watch/watchFilter.js';
+/** fs.watch(root, { recursive: true }), the production WatchFunction. */
+export const nodeWatch = (root, onEvent) => watch(root, { recursive: true }, (_eventType, filename) => onEvent(filename));
+/**
+ * Adapter: fs.watch to IWatcher. Drops events isWatchNoise rejects, calls
+ * onChange() without a path for the rest, and reports the first watcher
+ * error through onFailure exactly once.
+ */
+export class FsWatchAdapter {
+    root;
+    watchFunction;
+    handle;
+    failureReported = false;
+    constructor(root, watchFunction) {
+        this.root = root;
+        this.watchFunction = watchFunction;
+    }
+    start(listener) {
+        const reportFailure = (detail) => {
+            if (this.failureReported) {
+                return;
+            }
+            this.failureReported = true;
+            listener.onFailure(detail);
+        };
+        try {
+            this.handle = this.watchFunction(this.root, (filename) => {
+                if (!isWatchNoise(filename)) {
+                    listener.onChange();
+                }
+            });
+        }
+        catch (error) {
+            // fs.watch throws instead of emitting when the watch limit is already
+            // reached at start (risk 6.2); the daemon degrades to the poll either way.
+            reportFailure(errorMessage(error));
+            return;
+        }
+        this.handle.on('error', (error) => reportFailure(errorMessage(error)));
+    }
+    close() {
+        this.handle?.close();
+        this.handle = undefined;
+    }
+}

package/dist/cli/commands/hookCommand.d.ts

@@ -0,0 +1,29 @@
+import { type ExitCode } from '../../contracts/exitCode.js';
+import type { IFileSystem } from '../../contracts/IFileSystem.js';
+import type { IGitReader } from '../../contracts/IGitReader.js';
+import type { IRepositoryLocator, RepositoryPaths } from '../../contracts/IRepositoryLocator.js';
+import type { ITextSink } from '../../contracts/ITextSink.js';
+export interface HookCommandInput {
+    /** The hook's working directory (git runs hooks from the root). */
+    readonly startDir: string;
+}
+export interface HookCommandDeps {
+    readonly locator: IRepositoryLocator;
+    readonly fs: IFileSystem;
+    /** A reader whose git children inherit GIT_INDEX_FILE, so the check reads the index being committed. */
+    readonly openGit: (paths: RepositoryPaths) => IGitReader;
+    readonly stderr: ITextSink;
+}
+export interface HookCommandResult {
+    readonly exitCode: ExitCode;
+}
+/**
+ * Controller:
+ * 1. locator.locate(startDir); anything but found: notice, exit 0 (the hook fails open).
+ * 2. parseConfig of <root>/enmetu.config.json; a ConfigError prints a notice and
+ *    applies the defaults, so a broken config never blocks the commit that fixes it.
+ *    Unknown keys are ignored without a word: the daemon names them at start (design 14.17).
+ * 3. preCommitCheckController with the config's skipJsonCheck.
+ * 4. Violations: print the refusal of design 1.18 to stderr, exit 1. None: print nothing, exit 0.
+ */
+export declare function hookCommand(input: HookCommandInput, deps: HookCommandDeps): Promise<HookCommandResult>;