@agimon-ai/doompi-hook 0.0.1-alpha.7 → 0.0.1-alpha.71

package/dist/index-LpLV04fM.d.mts

@@ -0,0 +1,297 @@
+import { spawn } from "node:child_process";
+import { DoomTelemetryOptions } from "@agimon-ai/doompi-telemetry";
+import "@agimon-ai/doompi-config/types";
+import "@deepseek-ai/cordis";
+import "@earendil-works/pi-coding-agent";
+//#region src/constants/hooks.d.ts
+declare const HOOK_EVENT: {
+  readonly sessionStart: 'SessionStart';
+  readonly preToolUse: 'PreToolUse';
+  readonly postToolUse: 'PostToolUse';
+  readonly stop: 'Stop';
+  readonly sessionEnd: 'SessionEnd';
+};
+//#endregion
+//#region src/types/hooks.d.ts
+/**
+ * The hook document contract and the ports that run it.
+ *
+ * Every name here is written in Claude Code's vocabulary, because that is what
+ * `.doom/hooks.yaml` and plugin `hooks.json` files are authored against. The
+ * translation onto Pi's lifecycle happens at the adapter boundary.
+ */
+/** Registry event names. Each is used twice per dispatch, so drift would be silent. */
+type HookEventName = (typeof HOOK_EVENT)[keyof typeof HOOK_EVENT];
+interface HookCommand {
+  command: string;
+  /** Seconds before the hook is terminated. Defaults to DEFAULT_HOOK_TIMEOUT_SECONDS. */
+  timeout?: number;
+}
+/** What one registry row declares for the `pi` frontend. */
+interface RegistryBinding {
+  matcher?: string;
+  command: string;
+  timeout?: number;
+  skipInSubagent?: boolean;
+  order?: number;
+}
+/** A registry row plus the group membership used to include or drop it. */
+interface RegistryEntry extends RegistryBinding {
+  event: string;
+  order: number;
+  /** Declaration order across every source, used as the sort tiebreaker. */
+  position: number;
+  groupId: string;
+  core: boolean;
+  /** Root of the config that declared the group, exported as CLAUDE_PLUGIN_ROOT. */
+  baseDirectory: string;
+}
+interface RegistryGroup {
+  core?: boolean;
+  hooks?: Array<{
+    event: string;
+    pi?: RegistryBinding;
+  }>;
+}
+interface RegistryDocument {
+  groups?: Record<string, RegistryGroup>;
+}
+/** One `.doom/hooks.yaml` as read from disk, before it is parsed. */
+interface HookDocumentSource {
+  baseDirectory: string;
+  text: string;
+}
+/** One `.doom/hooks.yaml` after parsing, tagged with the root that declared it. */
+interface ParsedRegistrySource {
+  baseDirectory: string;
+  document: RegistryDocument;
+}
+interface PluginHookGroup {
+  matcher?: string;
+  hooks?: HookCommand[];
+}
+interface PluginHookConfig {
+  hooks?: Record<string, PluginHookGroup[]>;
+}
+/** A parsed plugin config plus the root exported to its commands. */
+interface PluginHookDocument {
+  pluginRoot: string;
+  config: PluginHookConfig;
+}
+/** A hook command paired with the config root it runs against. */
+interface ResolvedHook {
+  hook: HookCommand;
+  root: string;
+}
+/** The JSON a hook may write on stdout to steer or block the call it observed. */
+interface HookDecision {
+  decision?: string;
+  reason?: string;
+  hookSpecificOutput?: {
+    permissionDecision?: string;
+    reason?: string;
+    additionalContext?: string;
+  };
+}
+type HookFailureReason = 'spawn_failed' | 'non_zero_exit' | 'timeout' | 'invalid_json' | 'registry_read' | 'plugin_config';
+interface HookFailure {
+  command: string;
+  message: string;
+  reason: HookFailureReason;
+}
+interface HookOutcome {
+  decision?: HookDecision;
+  failure?: HookFailure;
+}
+/**
+ * The tool fields a payload is built from, named without importing Pi.
+ *
+ * Pi's ToolCallEvent and ToolResultEvent both satisfy this structurally, so the
+ * adapter forwards them unchanged and the payload builder stays host-neutral.
+ */
+interface HookToolEvent {
+  readonly type: string;
+  readonly toolName: string;
+  readonly input: unknown;
+  readonly content?: readonly unknown[];
+  readonly isError?: boolean;
+}
+/** The JSON document handed to a hook on stdin. */
+type HookPayload = Record<string, unknown>;
+interface HookRunOptions {
+  repoRoot: string;
+  /** Exported as CLAUDE_PLUGIN_ROOT so a hook can reach its own scripts. */
+  pluginRoot?: string;
+}
+/** Runs one hook command and reports what it decided or how it failed. */
+interface HookRunner {
+  run(hook: HookCommand, payload: HookPayload, options: HookRunOptions): Promise<HookOutcome>;
+}
+/** Registry rows for this repository, or the failure that emptied them. */
+interface RegistryRead {
+  entries: RegistryEntry[];
+  failure?: HookFailure;
+}
+/** Plugin configs that could be read, and one failure per config that could not. */
+interface PluginDocumentRead {
+  documents: PluginHookDocument[];
+  failures: HookFailure[];
+}
+/** Where a plugin declares its hooks. Mirrors the harness state entry. */
+interface PluginHookSourceRef {
+  readonly pluginRoot: string;
+  readonly configPath: string;
+}
+/** Reads the hook documents a session runs from. */
+interface HookDocumentReader {
+  registry(repoRoot: string): Promise<RegistryRead>;
+  plugins(sources: readonly PluginHookSourceRef[]): Promise<PluginDocumentRead>;
+}
+//#endregion
+//#region src/services/hookDecisions/index.d.ts
+declare function decisionsFrom(outcomes: ReadonlyArray<HookOutcome>): HookDecision[];
+declare function failuresFrom(outcomes: ReadonlyArray<HookOutcome>): HookFailure[];
+/** Both spellings a hook may use to refuse the call it observed. */
+declare function isDenied(decision: HookDecision | undefined): boolean;
+declare function decisionReason(decision: HookDecision | undefined): string | undefined;
+/** Context a hook wants added to the conversation rather than used to block. */
+declare function additionalContextsFrom(decisions: ReadonlyArray<HookDecision>): string[];
+/** What a post-tool hook has to say, whichever field it said it in. */
+declare function toolResultMessages(decisions: ReadonlyArray<HookDecision>): string[];
+/**
+ * A guardrail that never ran looks exactly like one that passed, so the agent is
+ * told which checks were missed and what its options are.
+ */
+declare function hookFailureMessage(failures: ReadonlyArray<HookFailure>): string;
+//#endregion
+//#region src/constants/telemetry.d.ts
+declare const HOOK_TELEMETRY_EVENT: {
+  readonly hookFailed: 'doom_pi_hook.failed';
+  readonly hookRegistryReadFailed: 'doom_pi_hook.registry_read_failed';
+};
+//#endregion
+//#region src/types/telemetry.d.ts
+/** Telemetry events this package reports, and the port that records them. */
+type HookTelemetryEventName = (typeof HOOK_TELEMETRY_EVENT)[keyof typeof HOOK_TELEMETRY_EVENT];
+type HookTelemetryAttributes = Record<string, string | number | boolean>;
+/**
+ * A hook that never ran is indistinguishable from one that passed, which is why
+ * both a failed run and an unreadable registry are worth reporting rather than
+ * swallowing.
+ */
+interface HookTelemetry {
+  recordError(event: HookTelemetryEventName, error: unknown, attributes?: HookTelemetryAttributes): Promise<void>;
+  recordWarning(event: HookTelemetryEventName, error: unknown, attributes?: HookTelemetryAttributes): Promise<void>;
+}
+//#endregion
+//#region src/services/hookDocuments/index.d.ts
+interface HookDocumentReaderOptions {
+  telemetry?: HookTelemetry;
+  /** Where the global `.doom` directory lives. Defaults to the user's home. */
+  homeDirectory?: string;
+  readFile?: (filePath: string) => Promise<string>;
+  warn?: (message: string) => void;
+}
+/**
+ * Reads `.doom/hooks.yaml` from the global config directory and the repository,
+ * and the plugin hook configs the harness resolved.
+ *
+ * Every file is re-read on every dispatch: it costs almost nothing and keeps an
+ * in-place rewrite visible, which an mtime check would miss when two writes land
+ * inside the same filesystem timestamp granularity. Both caches are keyed on
+ * contents instead, so parsing — the expensive half — is what they skip.
+ */
+declare function createHookDocumentReader(options?: HookDocumentReaderOptions): HookDocumentReader;
+//#endregion
+//#region src/services/hookPayload/index.d.ts
+/** The payload shape a Claude Code session hook is written against. */
+declare function toolHookPayload(event: HookToolEvent, hookEventName: string, repoRoot: string, sessionId: string): HookPayload;
+/** Session lifecycle hooks observe no tool, so they only need where and who. */
+declare function sessionHookPayload(sessionId: string, repoRoot: string): HookPayload;
+//#endregion
+//#region src/services/hookRegistry/index.d.ts
+/** Which rows a dispatch keeps, once the session's selection is known. */
+interface RegistrySelection {
+  event: string;
+  toolName?: string;
+  /** Selected group ids, or undefined for "every group", the standalone default. */
+  allowedGroups?: readonly string[];
+  inSubagent: boolean;
+}
+/**
+ * Identity of a set of registry sources, for callers that cache the parse.
+ *
+ * Keyed on contents rather than mtime, so it stays correct for an in-place
+ * rewrite and needs no invalidation hook. Reading both files is cheap; parsing
+ * is what a cache built on this skips.
+ */
+declare function registryCacheKey(sources: ReadonlyArray<HookDocumentSource>): string;
+/**
+ * Flattens parsed registry documents into sorted rows, keeping only bindings
+ * that declare a `pi` frontend.
+ *
+ * A later source replaces the group of the same id outright rather than merging
+ * into it, so a repository that redefines a group owns it completely.
+ */
+declare function registryEntries(sources: ReadonlyArray<ParsedRegistrySource>): RegistryEntry[];
+/**
+ * The rows one dispatch runs.
+ *
+ * Group selection changes when /mode switches mid-session, so inclusion is
+ * applied per call rather than being baked into a cached parse. Core groups
+ * always load; the rest are gated by the layers the harness resolved.
+ */
+declare function selectRegistryHooks(entries: ReadonlyArray<RegistryEntry>, selection: RegistrySelection): ResolvedHook[];
+//#endregion
+//#region src/services/hookRunner/index.d.ts
+interface BashHookRunnerOptions {
+  telemetry?: HookTelemetry;
+  env?: NodeJS.ProcessEnv;
+  platform?: NodeJS.Platform;
+  spawn?: typeof spawn;
+  warn?: (message: string) => void;
+}
+/**
+ * Runs advisory hook commands through bash and reports what each one decided.
+ *
+ * A hook is a command the repository owns, so it is spawned in its own process
+ * group and terminated as one: a hook that starts a server and stalls should
+ * not leave the server behind when the timeout fires.
+ */
+declare function createBashHookRunner(options?: BashHookRunnerOptions): HookRunner;
+//#endregion
+//#region src/services/hookRuntime/type.d.ts
+interface HookExtensionOptions {
+  telemetry?: HookTelemetry;
+  runner?: HookRunner;
+  documents?: HookDocumentReader;
+}
+//#endregion
+//#region src/services/hookTelemetry/index.d.ts
+interface HookTelemetryOptions {
+  cwd?: string;
+  workspaceRoot?: string;
+  env?: NodeJS.ProcessEnv;
+  telemetryFactory?: NonNullable<DoomTelemetryOptions['telemetryFactory']>;
+  warn?: (message: string) => void;
+}
+declare function createHookTelemetry(options?: HookTelemetryOptions): HookTelemetry;
+//#endregion
+//#region src/services/pluginHooks/index.d.ts
+/**
+ * The plugin hooks one dispatch runs.
+ *
+ * Plugin configs are the Claude Code `hooks.json` shape verbatim: an event name
+ * maps to groups, each with an optional matcher and a list of commands. Order
+ * follows the declaration order of the plugins the harness resolved.
+ */
+declare function selectPluginHooks(documents: ReadonlyArray<PluginHookDocument>, eventName: string, toolName?: string): ResolvedHook[];
+//#endregion
+//#region src/services/toolNames/index.d.ts
+/** The Claude name a hook matcher expects for a tool Pi just ran. */
+declare function toClaudeToolName(tool: string): string;
+/** Whether a matcher, if the row declares one, accepts the tool that fired. */
+declare function matchesTool(matcher: string | undefined, toolName: string | undefined): boolean;
+//#endregion
+export { HookDocumentReader as A, ParsedRegistrySource as B, decisionsFrom as C, toolResultMessages as D, isDenied as E, HookOutcome as F, PluginHookSourceRef as G, PluginHookConfig as H, HookPayload as I, RegistryEntry as J, RegistryBinding as K, HookRunOptions as L, HookEventName as M, HookFailure as N, HookCommand as O, HookFailureReason as P, HOOK_EVENT as Q, HookRunner as R, decisionReason as S, hookFailureMessage as T, PluginHookDocument as U, PluginDocumentRead as V, PluginHookGroup as W, RegistryRead as X, RegistryGroup as Y, ResolvedHook as Z, HookTelemetry as _, createHookTelemetry as a, HOOK_TELEMETRY_EVENT as b, createBashHookRunner as c, registryEntries as d, selectRegistryHooks as f, createHookDocumentReader as g, HookDocumentReaderOptions as h, HookTelemetryOptions as i, HookDocumentSource as j, HookDecision as k, RegistrySelection as l, toolHookPayload as m, toClaudeToolName as n, HookExtensionOptions as o, sessionHookPayload as p, RegistryDocument as q, selectPluginHooks as r, BashHookRunnerOptions as s, matchesTool as t, registryCacheKey as u, HookTelemetryAttributes as v, failuresFrom as w, additionalContextsFrom as x, HookTelemetryEventName as y, HookToolEvent as z };
+//# sourceMappingURL=index-LpLV04fM.d.mts.map

package/dist/index-LpLV04fM.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-LpLV04fM.d.mts","names":[],"sources":["../src/constants/hooks.ts","../src/types/hooks.ts","../src/services/hookDecisions/index.ts","../src/constants/telemetry.ts","../src/types/telemetry.ts","../src/services/hookDocuments/index.ts","../src/services/hookPayload/index.ts","../src/services/hookRegistry/index.ts","../src/services/hookRunner/index.ts","../src/services/hookRuntime/type.ts","../src/services/hookTelemetry/index.ts","../src/services/pluginHooks/index.ts","../src/services/toolNames/index.ts"],"mappings":";;;;;;cAAa;WACX;WACA;WACA;WACA;WACA;;;;;;;;;;;;KCMU,wBAAwB,yBAAyB;UAE5C;EACf;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;EACA;;;UAIe,sBAAsB;EACrC;EACA;;EAEA;EACA;EACA;;EAEA;;UAGe;EACf;EACA,QAAQ;IAAQ;IAAe,KAAK;;;UAGrB;EACf,SAAS,eAAe;;;UAIT;EACf;EACA;;;UAIe;EACf;EACA,UAAU;;UAGK;EACf;EACA,QAAQ;;UAGO;EACf,QAAQ,eAAe;;;UAIR;EACf;EACA,QAAQ;;;UAIO;EACf,MAAM;EACN;;;UAIe;EACf;EACA;EACA;IACE;IACA;IACA;;;KAIQ;UAQK;EACf;EACA;EACA,QAAQ;;UAGO;EACf,WAAW;EACX,UAAU;;;;;;;;UASK;WACN;WACA;WACA;WACA;WACA;;;KAIC,cAAc;UAET;EACf;;EAEA;;;UAIe;EACf,IAAI,MAAM,aAAa,SAAS,aAAa,SAAS,iBAAiB,QAAQ;;;UAIhE;EACf,SAAS;EACT,UAAU;;;UAIK;EACf,WAAW;EACX,UAAU;;;UAIK;WACN;WACA;;;UAIM;EACf,SAAS,mBAAmB,QAAQ;EACpC,QAAQ,kBAAkB,wBAAwB,QAAQ;;;;iBC9J5C,cAAc,UAAU,cAAc,eAAe;iBAIrD,aAAa,UAAU,cAAc,eAAe;;iBAKpD,SAAS,UAAU;iBAInB,eAAe,UAAU;;iBAKzB,uBAAuB,WAAW,cAAc;;iBAOhD,mBAAmB,WAAW,cAAc;;;;;iBAU5C,mBAAmB,UAAU,cAAc;;;cCtC9C;WACX;WACA;;;;;KCCU,iCAAiC,mCAAmC;KACpE,0BAA0B;;;;;;UAOrB;EACf,YAAY,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B;EAClG,cAAc,OAAO,wBAAwB,gBAAgB,aAAa,0BAA0B;;;;UCarF;EACf,YAAY;;EAEZ;EACA,YAAY,qBAAqB;EACjC,QAAQ;;;;;;;;;;;iBAoBM,yBAAyB,UAAS,4BAAiC;;;;iBC9CnE,gBACd,OAAO,eACP,uBACA,kBACA,oBACC;;iBAaa,mBAAmB,mBAAmB,mBAAmB;;;;UCnBxD;EACf;EACA;;EAEA;EACA;;;;;;;;;iBAUc,iBAAiB,SAAS,cAAc;;;;;;;;iBAWxC,gBAAgB,SAAS,cAAc,wBAAwB;;;;;;;;iBAqC/D,oBACd,SAAS,cAAc,gBACvB,WAAW,oBACV;;;UC7Cc;EACf,YAAY;EACZ,MAAM,OAAO;EACb,WAAW,OAAO;EAClB,eAAe;EACf,QAAQ;;;;;;;;;iBAcM,qBAAqB,UAAS,wBAA6B;;;UCtC1D;EACf,YAAY;EACZ,SAAS;EACT,YAAY;;;;UCJG;EACf;EACA;EACA,MAAM,OAAO;EACb,mBAAmB,YAAY;EAC/B,QAAQ;;iBAGM,oBAAoB,UAAS,uBAA4B;;;;;;;;;;iBCHzD,kBACd,WAAW,cAAc,qBACzB,mBACA,oBACC;;;;iBCKa,iBAAiB;;iBAKjB,YAAY,6BAA6B"}

package/dist/index.cjs

@@ -1 +1,22 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./types/telemetry.cjs"),t=require("./services/toolNames.cjs"),n=require("./services/hookRegistry.cjs"),r=require("./adapters/hookDocuments.cjs"),i=require("./adapters/hookRunner.cjs"),a=require("./adapters/telemetry/logSinkTelemetry.cjs"),o=require("./services/hookDecisions.cjs"),s=require("./services/hookPayload.cjs"),c=require("./services/pluginHooks.cjs"),l=require("./types/hooks.cjs"),u=require("./adapters/pi/extension.cjs");exports.HOOK_EVENT=l.HOOK_EVENT,exports.HOOK_TELEMETRY_EVENT=e.HOOK_TELEMETRY_EVENT,exports.additionalContextsFrom=o.additionalContextsFrom,exports.createBashHookRunner=i.createBashHookRunner,exports.createHookDocumentReader=r.createHookDocumentReader,exports.createHookTelemetry=a.createHookTelemetry,exports.decisionReason=o.decisionReason,exports.decisionsFrom=o.decisionsFrom,exports.failuresFrom=o.failuresFrom,exports.hookExtension=u.default,exports.hookFailureMessage=o.hookFailureMessage,exports.isDenied=o.isDenied,exports.matchesTool=t.matchesTool,exports.registryCacheKey=n.registryCacheKey,exports.registryEntries=n.registryEntries,exports.selectPluginHooks=c.selectPluginHooks,exports.selectRegistryHooks=n.selectRegistryHooks,exports.sessionHookPayload=s.sessionHookPayload,exports.toClaudeToolName=t.toClaudeToolName,exports.toolHookPayload=s.toolHookPayload,exports.toolResultMessages=o.toolResultMessages;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hooks = require("./hooks-CReMXrU9.cjs");
+exports.HOOK_EVENT = require_hooks.HOOK_EVENT;
+exports.HOOK_TELEMETRY_EVENT = require_hooks.HOOK_TELEMETRY_EVENT;
+exports.additionalContextsFrom = require_hooks.additionalContextsFrom;
+exports.createBashHookRunner = require_hooks.createBashHookRunner;
+exports.createHookDocumentReader = require_hooks.createHookDocumentReader;
+exports.createHookTelemetry = require_hooks.createHookTelemetry;
+exports.decisionReason = require_hooks.decisionReason;
+exports.decisionsFrom = require_hooks.decisionsFrom;
+exports.failuresFrom = require_hooks.failuresFrom;
+exports.hookFailureMessage = require_hooks.hookFailureMessage;
+exports.isDenied = require_hooks.isDenied;
+exports.matchesTool = require_hooks.matchesTool;
+exports.registryCacheKey = require_hooks.registryCacheKey;
+exports.registryEntries = require_hooks.registryEntries;
+exports.selectPluginHooks = require_hooks.selectPluginHooks;
+exports.selectRegistryHooks = require_hooks.selectRegistryHooks;
+exports.sessionHookPayload = require_hooks.sessionHookPayload;
+exports.toClaudeToolName = require_hooks.toClaudeToolName;
+exports.toolHookPayload = require_hooks.toolHookPayload;
+exports.toolResultMessages = require_hooks.toolResultMessages;

package/dist/index.d.mts

@@ -1,12 +1,2 @@
-import { HOOK_EVENT, HookCommand, HookDecision, HookDocumentReader, HookDocumentSource, HookEventName, HookFailure, HookFailureReason, HookOutcome, HookPayload, HookRunOptions, HookRunner, HookToolEvent, ParsedRegistrySource, PluginDocumentRead, PluginHookConfig, PluginHookDocument, PluginHookGroup, PluginHookSourceRef, RegistryBinding, RegistryDocument, RegistryEntry, RegistryGroup, RegistryRead, ResolvedHook } from "./types/hooks.mjs";
-import { HOOK_TELEMETRY_EVENT, HookTelemetry, HookTelemetryAttributes, HookTelemetryEventName } from "./types/telemetry.mjs";
-import hookExtension, { HookExtensionOptions } from "./adapters/pi/extension.mjs";
-import { HookDocumentReaderOptions, createHookDocumentReader } from "./adapters/hookDocuments.mjs";
-import { BashHookRunnerOptions, createBashHookRunner } from "./adapters/hookRunner.mjs";
-import { HookTelemetryOptions, createHookTelemetry } from "./adapters/telemetry/logSinkTelemetry.mjs";
-import { additionalContextsFrom, decisionReason, decisionsFrom, failuresFrom, hookFailureMessage, isDenied, toolResultMessages } from "./services/hookDecisions.mjs";
-import { sessionHookPayload, toolHookPayload } from "./services/hookPayload.mjs";
-import { RegistrySelection, registryCacheKey, registryEntries, selectRegistryHooks } from "./services/hookRegistry.mjs";
-import { selectPluginHooks } from "./services/pluginHooks.mjs";
-import { matchesTool, toClaudeToolName } from "./services/toolNames.mjs";
-export { type BashHookRunnerOptions, HOOK_EVENT, HOOK_TELEMETRY_EVENT, type HookCommand, type HookDecision, type HookDocumentReader, type HookDocumentReaderOptions, type HookDocumentSource, type HookEventName, type HookExtensionOptions, type HookFailure, type HookFailureReason, type HookOutcome, type HookPayload, type HookRunOptions, type HookRunner, type HookTelemetry, type HookTelemetryAttributes, type HookTelemetryEventName, type HookTelemetryOptions, type HookToolEvent, type ParsedRegistrySource, type PluginDocumentRead, type PluginHookConfig, type PluginHookDocument, type PluginHookGroup, type PluginHookSourceRef, type RegistryBinding, type RegistryDocument, type RegistryEntry, type RegistryGroup, type RegistryRead, type RegistrySelection, type ResolvedHook, additionalContextsFrom, createBashHookRunner, createHookDocumentReader, createHookTelemetry, decisionReason, decisionsFrom, failuresFrom, hookExtension, hookFailureMessage, isDenied, matchesTool, registryCacheKey, registryEntries, selectPluginHooks, selectRegistryHooks, sessionHookPayload, toClaudeToolName, toolHookPayload, toolResultMessages };
+import { A as HookDocumentReader, B as ParsedRegistrySource, C as decisionsFrom, D as toolResultMessages, E as isDenied, F as HookOutcome, G as PluginHookSourceRef, H as PluginHookConfig, I as HookPayload, J as RegistryEntry, K as RegistryBinding, L as HookRunOptions, M as HookEventName, N as HookFailure, O as HookCommand, P as HookFailureReason, Q as HOOK_EVENT, R as HookRunner, S as decisionReason, T as hookFailureMessage, U as PluginHookDocument, V as PluginDocumentRead, W as PluginHookGroup, X as RegistryRead, Y as RegistryGroup, Z as ResolvedHook, _ as HookTelemetry, a as createHookTelemetry, b as HOOK_TELEMETRY_EVENT, c as createBashHookRunner, d as registryEntries, f as selectRegistryHooks, g as createHookDocumentReader, h as HookDocumentReaderOptions, i as HookTelemetryOptions, j as HookDocumentSource, k as HookDecision, l as RegistrySelection, m as toolHookPayload, n as toClaudeToolName, o as HookExtensionOptions, p as sessionHookPayload, q as RegistryDocument, r as selectPluginHooks, s as BashHookRunnerOptions, t as matchesTool, u as registryCacheKey, v as HookTelemetryAttributes, w as failuresFrom, x as additionalContextsFrom, y as HookTelemetryEventName, z as HookToolEvent } from "./index-LpLV04fM.mjs";
+export { type BashHookRunnerOptions, HOOK_EVENT, HOOK_TELEMETRY_EVENT, type HookCommand, type HookDecision, type HookDocumentReader, type HookDocumentReaderOptions, type HookDocumentSource, type HookEventName, type HookExtensionOptions, type HookFailure, type HookFailureReason, type HookOutcome, type HookPayload, type HookRunOptions, type HookRunner, type HookTelemetry, type HookTelemetryAttributes, type HookTelemetryEventName, type HookTelemetryOptions, type HookToolEvent, type ParsedRegistrySource, type PluginDocumentRead, type PluginHookConfig, type PluginHookDocument, type PluginHookGroup, type PluginHookSourceRef, type RegistryBinding, type RegistryDocument, type RegistryEntry, type RegistryGroup, type RegistryRead, type RegistrySelection, type ResolvedHook, additionalContextsFrom, createBashHookRunner, createHookDocumentReader, createHookTelemetry, decisionReason, decisionsFrom, failuresFrom, hookFailureMessage, isDenied, matchesTool, registryCacheKey, registryEntries, selectPluginHooks, selectRegistryHooks, sessionHookPayload, toClaudeToolName, toolHookPayload, toolResultMessages };

package/dist/index.mjs

@@ -1 +1,2 @@
-import{HOOK_TELEMETRY_EVENT as e}from"./types/telemetry.mjs";import{matchesTool as t,toClaudeToolName as n}from"./services/toolNames.mjs";import{registryCacheKey as r,registryEntries as i,selectRegistryHooks as a}from"./services/hookRegistry.mjs";import{createHookDocumentReader as o}from"./adapters/hookDocuments.mjs";import{createBashHookRunner as s}from"./adapters/hookRunner.mjs";import{createHookTelemetry as c}from"./adapters/telemetry/logSinkTelemetry.mjs";import{additionalContextsFrom as l,decisionReason as u,decisionsFrom as d,failuresFrom as f,hookFailureMessage as p,isDenied as m,toolResultMessages as h}from"./services/hookDecisions.mjs";import{sessionHookPayload as g,toolHookPayload as _}from"./services/hookPayload.mjs";import{selectPluginHooks as v}from"./services/pluginHooks.mjs";import{HOOK_EVENT as y}from"./types/hooks.mjs";import b from"./adapters/pi/extension.mjs";export{y as HOOK_EVENT,e as HOOK_TELEMETRY_EVENT,l as additionalContextsFrom,s as createBashHookRunner,o as createHookDocumentReader,c as createHookTelemetry,u as decisionReason,d as decisionsFrom,f as failuresFrom,b as hookExtension,p as hookFailureMessage,m as isDenied,t as matchesTool,r as registryCacheKey,i as registryEntries,v as selectPluginHooks,a as selectRegistryHooks,g as sessionHookPayload,n as toClaudeToolName,_ as toolHookPayload,h as toolResultMessages};
+import { _ as failuresFrom, a as sessionHookPayload, b as toolResultMessages, c as registryCacheKey, d as matchesTool, f as toClaudeToolName, g as decisionsFrom, h as decisionReason, i as createBashHookRunner, l as registryEntries, m as additionalContextsFrom, n as selectPluginHooks, o as toolHookPayload, p as HOOK_TELEMETRY_EVENT, r as createHookTelemetry, s as createHookDocumentReader, t as HOOK_EVENT, u as selectRegistryHooks, v as hookFailureMessage, y as isDenied } from "./hooks-D2s_5hzZ.mjs";
+export { HOOK_EVENT, HOOK_TELEMETRY_EVENT, additionalContextsFrom, createBashHookRunner, createHookDocumentReader, createHookTelemetry, decisionReason, decisionsFrom, failuresFrom, hookFailureMessage, isDenied, matchesTool, registryCacheKey, registryEntries, selectPluginHooks, selectRegistryHooks, sessionHookPayload, toClaudeToolName, toolHookPayload, toolResultMessages };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agimon-ai/doompi-hook",
-  "version": "0.0.1-alpha.7",
+  "version": "0.0.1-alpha.71",
   "description": "Claude-Code-compatible repository and plugin hook runner for DoomPi sessions.",
   "keywords": [
     "ai",
@@ -16,8 +16,16 @@
     "repository-hooks"
   ],
   "homepage": "https://agimon.ai",
+  "bugs": {
+    "url": "https://github.com/AgiFlow/doompi/issues"
+  },
   "license": "MIT",
   "author": "Vuong Ngo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgiFlow/doompi.git",
+    "directory": "packages/default/doompi-hook"
+  },
   "files": [
     "dist",
     "llms.txt",
@@ -28,6 +36,7 @@
   ],
   "type": "module",
   "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "jsnext:main": "./dist/index.mjs",
   "exports": {
@@ -36,34 +45,45 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     },
+    "./apiContracts": {
+      "types": "./dist/apiContracts.d.mts",
+      "import": "./dist/apiContracts.mjs",
+      "require": "./dist/apiContracts.cjs"
+    },
     "./extensions/pi": {
       "types": "./dist/extensions/pi.d.mts",
       "import": "./dist/extensions/pi.mjs",
       "require": "./dist/extensions/pi.cjs"
     },
+    "./extensions/server": {
+      "types": "./dist/extensions/server.d.mts",
+      "import": "./dist/extensions/server.mjs",
+      "require": "./dist/extensions/server.cjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@deepseek-ai/cordis": "4.0.1",
-    "yaml": "2.9.0",
-    "@agimon-ai/doompi-config": "0.0.1-alpha.29",
-    "@agimon-ai/doompi-extension-contracts": "0.0.1-alpha.29",
-    "@agimon-ai/doompi-telemetry": "0.0.1-alpha.29"
+    "@agimon-ai/doompi-config": "0.0.1-alpha.93",
+    "@agimon-ai/doompi-core": "0.0.1-alpha.94",
+    "@agimon-ai/doompi-telemetry": "0.0.1-alpha.85",
+    "@deepseek-ai/cordis": "4.0.2",
+    "yaml": "2.9.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.2",
-    "@types/node": "26.2.0",
-    "@vitest/coverage-v8": "4.1.11",
-    "tsdown": "0.22.14",
+    "@agimon-ai/doompi-build": "0.0.1-alpha.17",
+    "@agimon-ai/vibe-lint-plugin-doom-extension": "0.0.1-alpha.83",
+    "@earendil-works/pi-coding-agent": "0.87.1",
+    "@types/node": "26.6.1",
+    "@vitest/coverage-v8": "5.0.1",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11",
-    "@agimon-ai/vibe-lint-plugin-doom-extension": "0.0.1-alpha.27"
+    "vitest": "5.0.1"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.2"
+    "@earendil-works/pi-coding-agent": "0.87.1"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
@@ -73,13 +93,32 @@
   "engines": {
     "node": ">=22.19.0"
   },
+  "doompiMcp": {
+    "entry": "./generated/mcp.ts",
+    "dist": "./dist/extensions/mcp.mjs",
+    "scopes": [
+      "session"
+    ]
+  },
+  "doompiServer": {
+    "entry": "./generated/server.ts",
+    "dist": "./dist/extensions/server.mjs",
+    "scopes": [
+      "session"
+    ],
+    "contracts": {
+      "entry": "./src/exports/apiContracts.ts",
+      "dist": "./dist/apiContracts.mjs"
+    }
+  },
   "pi": {
     "extensions": [
       "./dist/extensions/pi.mjs"
     ]
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && pnpm build:mcp",
+    "build:mcp": "tsdown --config tsdown.mcp.config.ts",
     "test": "vitest --run",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint . && oxfmt . --check",

package/dist/_virtual/_rolldown/runtime.cjs

@@ -1 +0,0 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));exports.__toESM=s;

package/dist/adapters/hookDocuments.cjs

@@ -1,2 +0,0 @@
-const e=require("../_virtual/_rolldown/runtime.cjs"),t=require("../types/telemetry.cjs"),n=require("../services/hookRegistry.cjs");let r=require("node:fs");r=e.__toESM(r,1);let i=require("@agimon-ai/doompi-config/layeredConfig"),a=require("yaml");function o(e){return e instanceof Error?e.message:String(e)}function s(e){return e?.code===`ENOENT`}function c(e={}){let c=e.readFile??(e=>r.default.promises.readFile(e,`utf8`)),l=e.telemetry,u=e.warn??(e=>void process.stderr.write(e)),d,f=[],p=new Map,m=async e=>{try{return{baseDirectory:e.baseDirectory,text:await c(e.filePath)}}catch(e){if(s(e))return;throw e}},h=e=>{let t=n.registryCacheKey(e);return d===t?f:(f=n.registryEntries(e.map(e=>({baseDirectory:e.baseDirectory,document:(0,a.parse)(e.text)??{}}))),d=t,f)};return{async registry(n){let r=(0,i.doomConfigCandidates)(`hooks.yaml`,n,e.homeDirectory),a=r.map(e=>e.filePath).join(` and `);try{let e=(await Promise.all(r.map(m))).filter(e=>e!==void 0);return{entries:h(e)}}catch(e){return l?.recordError(t.HOOK_TELEMETRY_EVENT.hookRegistryReadFailed,e,{"hook.registry.source":`repository`}),u(`[pi-hook] could not read ${a}: ${o(e)}\n`),{entries:[],failure:{command:a,message:o(e),reason:`registry_read`}}}},async plugins(e){let t=[],n=[];for(let r of e)try{let e=await c(r.configPath),n=p.get(r.configPath),i=n?.source===e?n.config:JSON.parse(e);p.set(r.configPath,{source:e,config:i}),t.push({pluginRoot:r.pluginRoot,config:i})}catch(e){n.push({command:r.configPath,message:o(e),reason:`plugin_config`})}return{documents:t,failures:n}}}}exports.createHookDocumentReader=c;
-//# sourceMappingURL=hookDocuments.cjs.map

package/dist/adapters/hookDocuments.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hookDocuments.cjs","names":["fs","registryCacheKey","registryEntries","parseYaml","doomConfigCandidates","HOOK_TELEMETRY_EVENT"],"sources":["../../src/adapters/hookDocuments.ts"],"sourcesContent":["import fs from 'node:fs';\nimport { doomConfigCandidates } from '@agimon-ai/doompi-config/layeredConfig';\nimport { parse as parseYaml } from 'yaml';\nimport type {\n  HookDocumentReader,\n  HookDocumentSource,\n  PluginDocumentRead,\n  PluginHookConfig,\n  PluginHookDocument,\n  PluginHookSourceRef,\n  RegistryDocument,\n  RegistryEntry,\n  RegistryRead,\n} from '../types/hooks.ts';\nimport { HOOK_TELEMETRY_EVENT, type HookTelemetry } from '../types/telemetry.ts';\nimport { registryCacheKey, registryEntries } from '../services/hookRegistry.ts';\n\nconst HOOKS_FILE = 'hooks.yaml';\nconst FILE_ENCODING = 'utf8';\nconst FILE_NOT_FOUND_ERROR = 'ENOENT';\nconst REGISTRY_SOURCE_ATTRIBUTE = 'repository';\n\nexport interface HookDocumentReaderOptions {\n  telemetry?: HookTelemetry;\n  /** Where the global `.doom` directory lives. Defaults to the user's home. */\n  homeDirectory?: string;\n  readFile?: (filePath: string) => Promise<string>;\n  warn?: (message: string) => void;\n}\n\nfunction reason(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction isMissingFile(error: unknown): boolean {\n  return (error as NodeJS.ErrnoException | undefined)?.code === FILE_NOT_FOUND_ERROR;\n}\n\n/**\n * Reads `.doom/hooks.yaml` from the global config directory and the repository,\n * and the plugin hook configs the harness resolved.\n *\n * Every file is re-read on every dispatch: it costs almost nothing and keeps an\n * in-place rewrite visible, which an mtime check would miss when two writes land\n * inside the same filesystem timestamp granularity. Both caches are keyed on\n * contents instead, so parsing — the expensive half — is what they skip.\n */\nexport function createHookDocumentReader(options: HookDocumentReaderOptions = {}): HookDocumentReader {\n  const readFile = options.readFile ?? ((filePath: string) => fs.promises.readFile(filePath, FILE_ENCODING));\n  const telemetry = options.telemetry;\n  const warn = options.warn ?? ((message: string) => void process.stderr.write(message));\n  let cachedRegistryKey: string | undefined;\n  let cachedRegistryEntries: RegistryEntry[] = [];\n  const pluginConfigCache = new Map<string, { source: string; config: PluginHookConfig }>();\n\n  const readSource = async (candidate: {\n    filePath: string;\n    baseDirectory: string;\n  }): Promise<HookDocumentSource | undefined> => {\n    try {\n      return { baseDirectory: candidate.baseDirectory, text: await readFile(candidate.filePath) };\n    } catch (error) {\n      if (isMissingFile(error)) return undefined;\n      throw error;\n    }\n  };\n\n  const parseSources = (sources: ReadonlyArray<HookDocumentSource>): RegistryEntry[] => {\n    const key = registryCacheKey(sources);\n    if (cachedRegistryKey === key) return cachedRegistryEntries;\n    cachedRegistryEntries = registryEntries(\n      sources.map((source) => ({\n        baseDirectory: source.baseDirectory,\n        document: (parseYaml(source.text) ?? {}) as RegistryDocument,\n      })),\n    );\n    cachedRegistryKey = key;\n    return cachedRegistryEntries;\n  };\n\n  return {\n    async registry(repoRoot: string): Promise<RegistryRead> {\n      const candidates = doomConfigCandidates(HOOKS_FILE, repoRoot, options.homeDirectory);\n      // Named for the error path only. A registry absent from both locations is\n      // a repository with no hooks, not a failure, so only a file that exists\n      // and cannot be read or parsed reaches the catch below.\n      const registryPath = candidates.map((candidate) => candidate.filePath).join(' and ');\n      try {\n        const sources = (await Promise.all(candidates.map(readSource))).filter(\n          (source): source is HookDocumentSource => source !== undefined,\n        );\n        return { entries: parseSources(sources) };\n      } catch (error) {\n        // This empties the registry for the whole dispatch, so every repository\n        // hook silently stops running rather than any one of them failing.\n        void telemetry?.recordError(HOOK_TELEMETRY_EVENT.hookRegistryReadFailed, error, {\n          'hook.registry.source': REGISTRY_SOURCE_ATTRIBUTE,\n        });\n        warn(`[pi-hook] could not read ${registryPath}: ${reason(error)}\\n`);\n        return { entries: [], failure: { command: registryPath, message: reason(error), reason: 'registry_read' } };\n      }\n    },\n\n    async plugins(sources: readonly PluginHookSourceRef[]): Promise<PluginDocumentRead> {\n      const documents: PluginHookDocument[] = [];\n      const failures: PluginDocumentRead['failures'] = [];\n      for (const source of sources) {\n        try {\n          const text = await readFile(source.configPath);\n          const cached = pluginConfigCache.get(source.configPath);\n          const config = cached?.source === text ? cached.config : (JSON.parse(text) as PluginHookConfig);\n          pluginConfigCache.set(source.configPath, { source: text, config });\n          documents.push({ pluginRoot: source.pluginRoot, config });\n        } catch (error) {\n          failures.push({ command: source.configPath, message: reason(error), reason: 'plugin_config' });\n        }\n      }\n      return { documents, failures };\n    },\n  };\n}\n"],"mappings":"uPA8BA,SAAS,EAAO,EAAwB,CACtC,OAAO,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,CAC9D,CAEA,SAAS,EAAc,EAAyB,CAC9C,OAAQ,GAA6C,OAAS,QAChE,CAWA,SAAgB,EAAyB,EAAqC,CAAC,EAAuB,CACpG,IAAM,EAAW,EAAQ,WAAc,GAAqBA,EAAAA,QAAG,SAAS,SAAS,EAAU,MAAa,GAClG,EAAY,EAAQ,UACpB,EAAO,EAAQ,OAAU,GAAoB,KAAK,QAAQ,OAAO,MAAM,CAAO,GAChF,EACA,EAAyC,CAAC,EACxC,EAAoB,IAAI,IAExB,EAAa,KAAO,IAGqB,CAC7C,GAAI,CACF,MAAO,CAAE,cAAe,EAAU,cAAe,KAAM,MAAM,EAAS,EAAU,QAAQ,CAAE,CAC5F,OAAS,EAAO,CACd,GAAI,EAAc,CAAK,EAAG,OAC1B,MAAM,CACR,CACF,EAEM,EAAgB,GAAgE,CACpF,IAAM,EAAMC,EAAAA,iBAAiB,CAAO,EASpC,OARI,IAAsB,EAAY,GACtC,EAAwBC,EAAAA,gBACtB,EAAQ,IAAK,IAAY,CACvB,cAAe,EAAO,cACtB,UAAA,EAAWC,EAAAA,MAAAA,CAAU,EAAO,IAAI,GAAK,CAAC,CACxC,EAAE,CACJ,EACA,EAAoB,EACb,EACT,EAEA,MAAO,CACL,MAAM,SAAS,EAAyC,CACtD,IAAM,GAAA,EAAaC,EAAAA,qBAAAA,CAAqB,aAAY,EAAU,EAAQ,aAAa,EAI7E,EAAe,EAAW,IAAK,GAAc,EAAU,QAAQ,CAAC,CAAC,KAAK,OAAO,EACnF,GAAI,CACF,IAAM,GAAW,MAAM,QAAQ,IAAI,EAAW,IAAI,CAAU,CAAC,EAAA,CAAG,OAC7D,GAAyC,IAAW,IAAA,EACvD,EACA,MAAO,CAAE,QAAS,EAAa,CAAO,CAAE,CAC1C,OAAS,EAAO,CAOd,OAJA,GAAgB,YAAYC,EAAAA,qBAAqB,uBAAwB,EAAO,CAC9E,uBAAwB,YAC1B,CAAC,EACD,EAAK,4BAA4B,EAAa,IAAI,EAAO,CAAK,EAAE,GAAG,EAC5D,CAAE,QAAS,CAAC,EAAG,QAAS,CAAE,QAAS,EAAc,QAAS,EAAO,CAAK,EAAG,OAAQ,eAAgB,CAAE,CAC5G,CACF,EAEA,MAAM,QAAQ,EAAsE,CAClF,IAAM,EAAkC,CAAC,EACnC,EAA2C,CAAC,EAClD,IAAK,IAAM,KAAU,EACnB,GAAI,CACF,IAAM,EAAO,MAAM,EAAS,EAAO,UAAU,EACvC,EAAS,EAAkB,IAAI,EAAO,UAAU,EAChD,EAAS,GAAQ,SAAW,EAAO,EAAO,OAAU,KAAK,MAAM,CAAI,EACzE,EAAkB,IAAI,EAAO,WAAY,CAAE,OAAQ,EAAM,QAAO,CAAC,EACjE,EAAU,KAAK,CAAE,WAAY,EAAO,WAAY,QAAO,CAAC,CAC1D,OAAS,EAAO,CACd,EAAS,KAAK,CAAE,QAAS,EAAO,WAAY,QAAS,EAAO,CAAK,EAAG,OAAQ,eAAgB,CAAC,CAC/F,CAEF,MAAO,CAAE,YAAW,UAAS,CAC/B,CACF,CACF"}

package/dist/adapters/hookDocuments.d.cts

@@ -1,23 +0,0 @@
-import { HookDocumentReader } from "../types/hooks.cjs";
-import { HookTelemetry } from "../types/telemetry.cjs";
-//#region src/adapters/hookDocuments.d.ts
-interface HookDocumentReaderOptions {
-  telemetry?: HookTelemetry;
-  /** Where the global `.doom` directory lives. Defaults to the user's home. */
-  homeDirectory?: string;
-  readFile?: (filePath: string) => Promise<string>;
-  warn?: (message: string) => void;
-}
-/**
- * Reads `.doom/hooks.yaml` from the global config directory and the repository,
- * and the plugin hook configs the harness resolved.
- *
- * Every file is re-read on every dispatch: it costs almost nothing and keeps an
- * in-place rewrite visible, which an mtime check would miss when two writes land
- * inside the same filesystem timestamp granularity. Both caches are keyed on
- * contents instead, so parsing — the expensive half — is what they skip.
- */
-declare function createHookDocumentReader(options?: HookDocumentReaderOptions): HookDocumentReader;
-//#endregion
-export { HookDocumentReaderOptions, createHookDocumentReader };
-//# sourceMappingURL=hookDocuments.d.cts.map

package/dist/adapters/hookDocuments.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hookDocuments.d.cts","names":[],"sources":["../../src/adapters/hookDocuments.ts"],"mappings":";;;UAsBiB;EACf,YAAY;;EAEZ;EACA,YAAY,qBAAqB;EACjC,QAAQ;;;;;;;;;;;iBAoBM,yBAAyB,UAAS,4BAAiC"}

package/dist/adapters/hookDocuments.d.mts

@@ -1,23 +0,0 @@
-import { HookDocumentReader } from "../types/hooks.mjs";
-import { HookTelemetry } from "../types/telemetry.mjs";
-//#region src/adapters/hookDocuments.d.ts
-interface HookDocumentReaderOptions {
-  telemetry?: HookTelemetry;
-  /** Where the global `.doom` directory lives. Defaults to the user's home. */
-  homeDirectory?: string;
-  readFile?: (filePath: string) => Promise<string>;
-  warn?: (message: string) => void;
-}
-/**
- * Reads `.doom/hooks.yaml` from the global config directory and the repository,
- * and the plugin hook configs the harness resolved.
- *
- * Every file is re-read on every dispatch: it costs almost nothing and keeps an
- * in-place rewrite visible, which an mtime check would miss when two writes land
- * inside the same filesystem timestamp granularity. Both caches are keyed on
- * contents instead, so parsing — the expensive half — is what they skip.
- */
-declare function createHookDocumentReader(options?: HookDocumentReaderOptions): HookDocumentReader;
-//#endregion
-export { HookDocumentReaderOptions, createHookDocumentReader };
-//# sourceMappingURL=hookDocuments.d.mts.map

package/dist/adapters/hookDocuments.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hookDocuments.d.mts","names":[],"sources":["../../src/adapters/hookDocuments.ts"],"mappings":";;;UAsBiB;EACf,YAAY;;EAEZ;EACA,YAAY,qBAAqB;EACjC,QAAQ;;;;;;;;;;;iBAoBM,yBAAyB,UAAS,4BAAiC"}

package/dist/adapters/hookDocuments.mjs

@@ -1,2 +0,0 @@
-import{HOOK_TELEMETRY_EVENT as e}from"../types/telemetry.mjs";import{registryCacheKey as t,registryEntries as n}from"../services/hookRegistry.mjs";import r from"node:fs";import{doomConfigCandidates as i}from"@agimon-ai/doompi-config/layeredConfig";import{parse as a}from"yaml";function o(e){return e instanceof Error?e.message:String(e)}function s(e){return e?.code===`ENOENT`}function c(c={}){let l=c.readFile??(e=>r.promises.readFile(e,`utf8`)),u=c.telemetry,d=c.warn??(e=>void process.stderr.write(e)),f,p=[],m=new Map,h=async e=>{try{return{baseDirectory:e.baseDirectory,text:await l(e.filePath)}}catch(e){if(s(e))return;throw e}},g=e=>{let r=t(e);return f===r?p:(p=n(e.map(e=>({baseDirectory:e.baseDirectory,document:a(e.text)??{}}))),f=r,p)};return{async registry(t){let n=i(`hooks.yaml`,t,c.homeDirectory),r=n.map(e=>e.filePath).join(` and `);try{let e=(await Promise.all(n.map(h))).filter(e=>e!==void 0);return{entries:g(e)}}catch(t){return u?.recordError(e.hookRegistryReadFailed,t,{"hook.registry.source":`repository`}),d(`[pi-hook] could not read ${r}: ${o(t)}\n`),{entries:[],failure:{command:r,message:o(t),reason:`registry_read`}}}},async plugins(e){let t=[],n=[];for(let r of e)try{let e=await l(r.configPath),n=m.get(r.configPath),i=n?.source===e?n.config:JSON.parse(e);m.set(r.configPath,{source:e,config:i}),t.push({pluginRoot:r.pluginRoot,config:i})}catch(e){n.push({command:r.configPath,message:o(e),reason:`plugin_config`})}return{documents:t,failures:n}}}}export{c as createHookDocumentReader};
-//# sourceMappingURL=hookDocuments.mjs.map

package/dist/adapters/hookDocuments.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hookDocuments.mjs","names":["parseYaml"],"sources":["../../src/adapters/hookDocuments.ts"],"sourcesContent":["import fs from 'node:fs';\nimport { doomConfigCandidates } from '@agimon-ai/doompi-config/layeredConfig';\nimport { parse as parseYaml } from 'yaml';\nimport type {\n  HookDocumentReader,\n  HookDocumentSource,\n  PluginDocumentRead,\n  PluginHookConfig,\n  PluginHookDocument,\n  PluginHookSourceRef,\n  RegistryDocument,\n  RegistryEntry,\n  RegistryRead,\n} from '../types/hooks.ts';\nimport { HOOK_TELEMETRY_EVENT, type HookTelemetry } from '../types/telemetry.ts';\nimport { registryCacheKey, registryEntries } from '../services/hookRegistry.ts';\n\nconst HOOKS_FILE = 'hooks.yaml';\nconst FILE_ENCODING = 'utf8';\nconst FILE_NOT_FOUND_ERROR = 'ENOENT';\nconst REGISTRY_SOURCE_ATTRIBUTE = 'repository';\n\nexport interface HookDocumentReaderOptions {\n  telemetry?: HookTelemetry;\n  /** Where the global `.doom` directory lives. Defaults to the user's home. */\n  homeDirectory?: string;\n  readFile?: (filePath: string) => Promise<string>;\n  warn?: (message: string) => void;\n}\n\nfunction reason(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction isMissingFile(error: unknown): boolean {\n  return (error as NodeJS.ErrnoException | undefined)?.code === FILE_NOT_FOUND_ERROR;\n}\n\n/**\n * Reads `.doom/hooks.yaml` from the global config directory and the repository,\n * and the plugin hook configs the harness resolved.\n *\n * Every file is re-read on every dispatch: it costs almost nothing and keeps an\n * in-place rewrite visible, which an mtime check would miss when two writes land\n * inside the same filesystem timestamp granularity. Both caches are keyed on\n * contents instead, so parsing — the expensive half — is what they skip.\n */\nexport function createHookDocumentReader(options: HookDocumentReaderOptions = {}): HookDocumentReader {\n  const readFile = options.readFile ?? ((filePath: string) => fs.promises.readFile(filePath, FILE_ENCODING));\n  const telemetry = options.telemetry;\n  const warn = options.warn ?? ((message: string) => void process.stderr.write(message));\n  let cachedRegistryKey: string | undefined;\n  let cachedRegistryEntries: RegistryEntry[] = [];\n  const pluginConfigCache = new Map<string, { source: string; config: PluginHookConfig }>();\n\n  const readSource = async (candidate: {\n    filePath: string;\n    baseDirectory: string;\n  }): Promise<HookDocumentSource | undefined> => {\n    try {\n      return { baseDirectory: candidate.baseDirectory, text: await readFile(candidate.filePath) };\n    } catch (error) {\n      if (isMissingFile(error)) return undefined;\n      throw error;\n    }\n  };\n\n  const parseSources = (sources: ReadonlyArray<HookDocumentSource>): RegistryEntry[] => {\n    const key = registryCacheKey(sources);\n    if (cachedRegistryKey === key) return cachedRegistryEntries;\n    cachedRegistryEntries = registryEntries(\n      sources.map((source) => ({\n        baseDirectory: source.baseDirectory,\n        document: (parseYaml(source.text) ?? {}) as RegistryDocument,\n      })),\n    );\n    cachedRegistryKey = key;\n    return cachedRegistryEntries;\n  };\n\n  return {\n    async registry(repoRoot: string): Promise<RegistryRead> {\n      const candidates = doomConfigCandidates(HOOKS_FILE, repoRoot, options.homeDirectory);\n      // Named for the error path only. A registry absent from both locations is\n      // a repository with no hooks, not a failure, so only a file that exists\n      // and cannot be read or parsed reaches the catch below.\n      const registryPath = candidates.map((candidate) => candidate.filePath).join(' and ');\n      try {\n        const sources = (await Promise.all(candidates.map(readSource))).filter(\n          (source): source is HookDocumentSource => source !== undefined,\n        );\n        return { entries: parseSources(sources) };\n      } catch (error) {\n        // This empties the registry for the whole dispatch, so every repository\n        // hook silently stops running rather than any one of them failing.\n        void telemetry?.recordError(HOOK_TELEMETRY_EVENT.hookRegistryReadFailed, error, {\n          'hook.registry.source': REGISTRY_SOURCE_ATTRIBUTE,\n        });\n        warn(`[pi-hook] could not read ${registryPath}: ${reason(error)}\\n`);\n        return { entries: [], failure: { command: registryPath, message: reason(error), reason: 'registry_read' } };\n      }\n    },\n\n    async plugins(sources: readonly PluginHookSourceRef[]): Promise<PluginDocumentRead> {\n      const documents: PluginHookDocument[] = [];\n      const failures: PluginDocumentRead['failures'] = [];\n      for (const source of sources) {\n        try {\n          const text = await readFile(source.configPath);\n          const cached = pluginConfigCache.get(source.configPath);\n          const config = cached?.source === text ? cached.config : (JSON.parse(text) as PluginHookConfig);\n          pluginConfigCache.set(source.configPath, { source: text, config });\n          documents.push({ pluginRoot: source.pluginRoot, config });\n        } catch (error) {\n          failures.push({ command: source.configPath, message: reason(error), reason: 'plugin_config' });\n        }\n      }\n      return { documents, failures };\n    },\n  };\n}\n"],"mappings":"qRA8BA,SAAS,EAAO,EAAwB,CACtC,OAAO,aAAiB,MAAQ,EAAM,QAAU,OAAO,CAAK,CAC9D,CAEA,SAAS,EAAc,EAAyB,CAC9C,OAAQ,GAA6C,OAAS,QAChE,CAWA,SAAgB,EAAyB,EAAqC,CAAC,EAAuB,CACpG,IAAM,EAAW,EAAQ,WAAc,GAAqB,EAAG,SAAS,SAAS,EAAU,MAAa,GAClG,EAAY,EAAQ,UACpB,EAAO,EAAQ,OAAU,GAAoB,KAAK,QAAQ,OAAO,MAAM,CAAO,GAChF,EACA,EAAyC,CAAC,EACxC,EAAoB,IAAI,IAExB,EAAa,KAAO,IAGqB,CAC7C,GAAI,CACF,MAAO,CAAE,cAAe,EAAU,cAAe,KAAM,MAAM,EAAS,EAAU,QAAQ,CAAE,CAC5F,OAAS,EAAO,CACd,GAAI,EAAc,CAAK,EAAG,OAC1B,MAAM,CACR,CACF,EAEM,EAAgB,GAAgE,CACpF,IAAM,EAAM,EAAiB,CAAO,EASpC,OARI,IAAsB,EAAY,GACtC,EAAwB,EACtB,EAAQ,IAAK,IAAY,CACvB,cAAe,EAAO,cACtB,SAAWA,EAAU,EAAO,IAAI,GAAK,CAAC,CACxC,EAAE,CACJ,EACA,EAAoB,EACb,EACT,EAEA,MAAO,CACL,MAAM,SAAS,EAAyC,CACtD,IAAM,EAAa,EAAqB,aAAY,EAAU,EAAQ,aAAa,EAI7E,EAAe,EAAW,IAAK,GAAc,EAAU,QAAQ,CAAC,CAAC,KAAK,OAAO,EACnF,GAAI,CACF,IAAM,GAAW,MAAM,QAAQ,IAAI,EAAW,IAAI,CAAU,CAAC,EAAA,CAAG,OAC7D,GAAyC,IAAW,IAAA,EACvD,EACA,MAAO,CAAE,QAAS,EAAa,CAAO,CAAE,CAC1C,OAAS,EAAO,CAOd,OAJA,GAAgB,YAAY,EAAqB,uBAAwB,EAAO,CAC9E,uBAAwB,YAC1B,CAAC,EACD,EAAK,4BAA4B,EAAa,IAAI,EAAO,CAAK,EAAE,GAAG,EAC5D,CAAE,QAAS,CAAC,EAAG,QAAS,CAAE,QAAS,EAAc,QAAS,EAAO,CAAK,EAAG,OAAQ,eAAgB,CAAE,CAC5G,CACF,EAEA,MAAM,QAAQ,EAAsE,CAClF,IAAM,EAAkC,CAAC,EACnC,EAA2C,CAAC,EAClD,IAAK,IAAM,KAAU,EACnB,GAAI,CACF,IAAM,EAAO,MAAM,EAAS,EAAO,UAAU,EACvC,EAAS,EAAkB,IAAI,EAAO,UAAU,EAChD,EAAS,GAAQ,SAAW,EAAO,EAAO,OAAU,KAAK,MAAM,CAAI,EACzE,EAAkB,IAAI,EAAO,WAAY,CAAE,OAAQ,EAAM,QAAO,CAAC,EACjE,EAAU,KAAK,CAAE,WAAY,EAAO,WAAY,QAAO,CAAC,CAC1D,OAAS,EAAO,CACd,EAAS,KAAK,CAAE,QAAS,EAAO,WAAY,QAAS,EAAO,CAAK,EAAG,OAAQ,eAAgB,CAAC,CAC/F,CAEF,MAAO,CAAE,YAAW,UAAS,CAC/B,CACF,CACF"}

package/dist/adapters/hookRunner.cjs

@@ -1,2 +0,0 @@
-const e=require("../types/telemetry.cjs");let t=require("node:child_process");const n=`ESRCH`,r=/\r?\n/;function i(e){return e instanceof Error&&`code`in e?String(e.code):void 0}function a(a={}){let o=a.spawn??t.spawn,s=a.telemetry,c=a.warn??(e=>void process.stderr.write(e)),l=(a.platform??process.platform)!==`win32`,u=(e,t)=>r=>{try{if(l&&e!==void 0){process.kill(-e,r);return}t(r)}catch(e){i(e)!==n&&process.emitWarning(`Could not signal repository hook process: ${String(e)}`)}};return{run(t,d,f){let p=t.timeout??10,m=a.env??process.env;return new Promise(a=>{let h=o(`/bin/bash`,[`-c`,t.command],{cwd:f.repoRoot,env:{...m,CLAUDE_PROJECT_DIR:f.repoRoot,CODEX_REPO_ROOT:f.repoRoot,ORIGINAL_REPO_PATH:m.ORIGINAL_REPO_PATH??f.repoRoot,...f.pluginRoot?{CLAUDE_PLUGIN_ROOT:f.pluginRoot}:{}},stdio:[`pipe`,`pipe`,`pipe`],detached:l}),g=``,_=``,v=!1,y=!1,b=!1,x=null,S,C=u(h.pid,e=>h.kill(e)),w=()=>{if(!l||h.pid===void 0)return!b;try{return process.kill(-h.pid,0),!0}catch(e){return i(e)!==n}},T=(e={})=>{v||(v=!0,clearTimeout(D),S&&clearTimeout(S),a(e))},E=()=>{let n=`Hook timed out after ${p} seconds.`;s?.recordWarning(e.HOOK_TELEMETRY_EVENT.hookFailed,n,{"hook.reason":`timeout`,"hook.exit_code":x??-1}),c(`[pi-hook] advisory hook timed out: ${t.command}\n${_}`),T({failure:{command:t.command,message:n,reason:`timeout`}})},D=setTimeout(()=>{y=!0,C(`SIGTERM`),S=setTimeout(()=>{w()&&C(`SIGKILL`),E()},2e3)},p*1e3);h.stdout?.on(`data`,e=>{g+=e.toString()}),h.stderr?.on(`data`,e=>{_+=e.toString()}),h.once(`error`,n=>{y||(s?.recordError(e.HOOK_TELEMETRY_EVENT.hookFailed,n,{"hook.reason":`spawn_failed`}),c(`[pi-hook] advisory hook failed: ${n.message}\n`),T({failure:{command:t.command,message:n.message,reason:`spawn_failed`}}))}),h.once(`exit`,n=>{if(b=!0,x=n,y)return;if(n!==0){let r=_.trim()||`Advisory hook exited with code ${n??`unknown`}`;s?.recordWarning(e.HOOK_TELEMETRY_EVENT.hookFailed,r,{"hook.reason":`non_zero_exit`,"hook.exit_code":n??-1}),c(`[pi-hook] advisory hook failed (${n}): ${t.command}\n${_}`),T({failure:{command:t.command,message:r,reason:`non_zero_exit`}});return}let i=g.trim().split(r).reverse().find(e=>e.startsWith(`{`));if(!i){T();return}try{T({decision:JSON.parse(i)})}catch(n){s?.recordWarning(e.HOOK_TELEMETRY_EVENT.hookFailed,n,{"hook.reason":`invalid_json`}),c(`[pi-hook] advisory hook returned invalid JSON: ${t.command}\n`),T({failure:{command:t.command,message:n instanceof Error?n.message:String(n),reason:`invalid_json`}})}}),h.stdin?.end(JSON.stringify(d))})}}}exports.createBashHookRunner=a;
-//# sourceMappingURL=hookRunner.cjs.map

package/dist/adapters/hookRunner.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hookRunner.cjs","names":["spawnProcess","HOOK_TELEMETRY_EVENT"],"sources":["../../src/adapters/hookRunner.ts"],"sourcesContent":["import { spawn as spawnProcess } from 'node:child_process';\nimport type {\n  HookCommand,\n  HookDecision,\n  HookOutcome,\n  HookPayload,\n  HookRunOptions,\n  HookRunner,\n} from '../types/hooks.ts';\nimport { HOOK_TELEMETRY_EVENT, type HookTelemetry } from '../types/telemetry.ts';\n\nconst HOOK_SHELL = '/bin/bash';\nconst HOOK_SHELL_COMMAND_FLAG = '-c';\nconst HOOK_TERMINATION_GRACE_MS = 2_000;\nconst DEFAULT_HOOK_TIMEOUT_SECONDS = 10;\nconst MILLISECONDS_PER_SECOND = 1_000;\nconst PROCESS_NOT_FOUND_ERROR = 'ESRCH';\nconst WINDOWS_PLATFORM = 'win32';\nconst UNKNOWN_EXIT_CODE = -1;\nconst JSON_LINE_START = '{';\nconst LINE_BREAK = /\\r?\\n/;\n\nexport interface BashHookRunnerOptions {\n  telemetry?: HookTelemetry;\n  env?: NodeJS.ProcessEnv;\n  platform?: NodeJS.Platform;\n  spawn?: typeof spawnProcess;\n  warn?: (message: string) => void;\n}\n\nfunction errorCode(error: unknown): string | undefined {\n  return error instanceof Error && 'code' in error ? String(error.code) : undefined;\n}\n\n/**\n * Runs advisory hook commands through bash and reports what each one decided.\n *\n * A hook is a command the repository owns, so it is spawned in its own process\n * group and terminated as one: a hook that starts a server and stalls should\n * not leave the server behind when the timeout fires.\n */\nexport function createBashHookRunner(options: BashHookRunnerOptions = {}): HookRunner {\n  const spawn = options.spawn ?? spawnProcess;\n  const telemetry = options.telemetry;\n  const warn = options.warn ?? ((message: string) => void process.stderr.write(message));\n  const useProcessGroup = (options.platform ?? process.platform) !== WINDOWS_PLATFORM;\n\n  const signalOwnedProcess = (\n    pid: number | undefined,\n    kill: (signal: NodeJS.Signals) => void,\n  ): ((signal: NodeJS.Signals) => void) => {\n    return (signal) => {\n      try {\n        if (useProcessGroup && pid !== undefined) {\n          process.kill(-pid, signal);\n          return;\n        }\n        kill(signal);\n      } catch (error) {\n        if (errorCode(error) !== PROCESS_NOT_FOUND_ERROR) {\n          process.emitWarning(`Could not signal repository hook process: ${String(error)}`);\n        }\n      }\n    };\n  };\n\n  return {\n    run(hook: HookCommand, payload: HookPayload, runOptions: HookRunOptions): Promise<HookOutcome> {\n      const timeoutSeconds = hook.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS;\n      const environment = options.env ?? process.env;\n      return new Promise((resolve) => {\n        // -c, not -lc. Hooks run on every tool call, and a login shell would\n        // source the developer's profile each time: per-call latency plus hook\n        // behavior that varies with their dotfiles. The child inherits the\n        // environment below, so it keeps the PATH the launcher started with.\n        const child = spawn(HOOK_SHELL, [HOOK_SHELL_COMMAND_FLAG, hook.command], {\n          cwd: runOptions.repoRoot,\n          env: {\n            ...environment,\n            CLAUDE_PROJECT_DIR: runOptions.repoRoot,\n            CODEX_REPO_ROOT: runOptions.repoRoot,\n            ORIGINAL_REPO_PATH: environment.ORIGINAL_REPO_PATH ?? runOptions.repoRoot,\n            ...(runOptions.pluginRoot ? { CLAUDE_PLUGIN_ROOT: runOptions.pluginRoot } : {}),\n          },\n          stdio: ['pipe', 'pipe', 'pipe'],\n          detached: useProcessGroup,\n        });\n        let stdout = '';\n        let stderr = '';\n        let settled = false;\n        let timedOut = false;\n        let childExited = false;\n        let timeoutExitCode: number | null = null;\n        let escalationTimer: NodeJS.Timeout | undefined;\n\n        const signal = signalOwnedProcess(child.pid, (value) => child.kill(value));\n\n        const ownedProcessIsAlive = (): boolean => {\n          if (!useProcessGroup || child.pid === undefined) return !childExited;\n          try {\n            process.kill(-child.pid, 0);\n            return true;\n          } catch (error) {\n            return errorCode(error) !== PROCESS_NOT_FOUND_ERROR;\n          }\n        };\n\n        const finish = (outcome: HookOutcome = {}): void => {\n          if (settled) return;\n          settled = true;\n          clearTimeout(timer);\n          if (escalationTimer) clearTimeout(escalationTimer);\n          resolve(outcome);\n        };\n\n        const finishTimeout = (): void => {\n          const message = `Hook timed out after ${timeoutSeconds} seconds.`;\n          void telemetry?.recordWarning(HOOK_TELEMETRY_EVENT.hookFailed, message, {\n            'hook.reason': 'timeout',\n            'hook.exit_code': timeoutExitCode ?? UNKNOWN_EXIT_CODE,\n          });\n          warn(`[pi-hook] advisory hook timed out: ${hook.command}\\n${stderr}`);\n          finish({ failure: { command: hook.command, message, reason: 'timeout' } });\n        };\n\n        const timer = setTimeout(() => {\n          timedOut = true;\n          signal('SIGTERM');\n          escalationTimer = setTimeout(() => {\n            if (ownedProcessIsAlive()) signal('SIGKILL');\n            finishTimeout();\n          }, HOOK_TERMINATION_GRACE_MS);\n        }, timeoutSeconds * MILLISECONDS_PER_SECOND);\n\n        child.stdout?.on('data', (chunk: Buffer) => {\n          stdout += chunk.toString();\n        });\n        child.stderr?.on('data', (chunk: Buffer) => {\n          stderr += chunk.toString();\n        });\n        child.once('error', (error: Error) => {\n          if (timedOut) return;\n          // A guardrail that never ran is indistinguishable from one that\n          // passed, which is the whole reason these are worth reporting.\n          void telemetry?.recordError(HOOK_TELEMETRY_EVENT.hookFailed, error, { 'hook.reason': 'spawn_failed' });\n          warn(`[pi-hook] advisory hook failed: ${error.message}\\n`);\n          finish({ failure: { command: hook.command, message: error.message, reason: 'spawn_failed' } });\n        });\n        child.once('exit', (code: number | null) => {\n          childExited = true;\n          timeoutExitCode = code;\n          if (timedOut) return;\n          if (code !== 0) {\n            const message = stderr.trim() || `Advisory hook exited with code ${code ?? 'unknown'}`;\n            void telemetry?.recordWarning(HOOK_TELEMETRY_EVENT.hookFailed, message, {\n              'hook.reason': 'non_zero_exit',\n              'hook.exit_code': code ?? UNKNOWN_EXIT_CODE,\n            });\n            warn(`[pi-hook] advisory hook failed (${code}): ${hook.command}\\n${stderr}`);\n            finish({ failure: { command: hook.command, message, reason: 'non_zero_exit' } });\n            return;\n          }\n          const jsonLine = stdout\n            .trim()\n            .split(LINE_BREAK)\n            .reverse()\n            .find((line) => line.startsWith(JSON_LINE_START));\n          if (!jsonLine) {\n            finish();\n            return;\n          }\n          try {\n            finish({ decision: JSON.parse(jsonLine) as HookDecision });\n          } catch (error) {\n            // The hook ran and had an opinion, and it was dropped.\n            void telemetry?.recordWarning(HOOK_TELEMETRY_EVENT.hookFailed, error, { 'hook.reason': 'invalid_json' });\n            warn(`[pi-hook] advisory hook returned invalid JSON: ${hook.command}\\n`);\n            finish({\n              failure: {\n                command: hook.command,\n                message: error instanceof Error ? error.message : String(error),\n                reason: 'invalid_json',\n              },\n            });\n          }\n        });\n        child.stdin?.end(JSON.stringify(payload));\n      });\n    },\n  };\n}\n"],"mappings":"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"}