@mmnto/cli 1.34.3 → 1.36.0

package/dist/hook/schema.d.ts

@@ -0,0 +1,385 @@
+import { z } from 'zod';
+/**
+ * Hook rule schemas for the bot-pack wiring engine (ADR-104).
+ *
+ * Two surfaces:
+ * - `HooksYamlSchema` describes a pack's `hooks.yaml` (authoring surface).
+ * - `CompiledHooksManifestSchema` describes `.totem/compiled-hooks.json`
+ *   (runtime surface produced by `totem sync` from installed packs).
+ *
+ * The compiled manifest carries the staleness metadata required by
+ * ADR-104 § Decision 3: schemaVersion + compiledAt + sourcePackVersions.
+ */
+declare const HookCheckTypeSchema: z.ZodEnum<["reject-if-match", "reject-if-no-match"]>;
+export type HookCheckType = z.infer<typeof HookCheckTypeSchema>;
+/**
+ * Authoring-surface schema for a single hook rule in a pack's `hooks.yaml`.
+ *
+ * The optional `recoveryHint` field (ADR-104 § Decision 1) gives agents the
+ * WHAT-INSTEAD on a block — recommended but not required in V1. Adoption
+ * tracked toward a V2 upgrade-to-required trigger (>80% of published rules
+ * carry it, OR an empirically-observed retry-loop incident).
+ *
+ * The `verification_shadow` field is reserved for the Spine Rule
+ * classification path (ADR-104 § Convergence + Q1 binding). In V1 the engine
+ * MUST warn-and-ignore any verification_shadow on a hook rule (hooks are
+ * Interpretive Rule class — no formal verification obligation). Schema
+ * accepts it permissively so future Spine-Rule promotion does not require
+ * a schema break.
+ */
+export declare const HookRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    trigger: z.ZodObject<{
+        tool: z.ZodString;
+        pattern: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        pattern: string;
+    }, {
+        tool: string;
+        pattern: string;
+    }>;
+    check: z.ZodObject<{
+        pattern: z.ZodEffects<z.ZodString, string, string>;
+        type: z.ZodEnum<["reject-if-match", "reject-if-no-match"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    }, {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    }>;
+    message: z.ZodString;
+    recoveryHint: z.ZodOptional<z.ZodString>;
+    verification_shadow: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    check: {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    };
+    message: string;
+    id: string;
+    trigger: {
+        tool: string;
+        pattern: string;
+    };
+    recoveryHint?: string | undefined;
+    verification_shadow?: unknown;
+}, {
+    check: {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    };
+    message: string;
+    id: string;
+    trigger: {
+        tool: string;
+        pattern: string;
+    };
+    recoveryHint?: string | undefined;
+    verification_shadow?: unknown;
+}>;
+export type HookRule = z.infer<typeof HookRuleSchema>;
+export declare const HOOKS_YAML_SCHEMA_VERSION: 1;
+/**
+ * Per-pack `hooks.yaml` file shape. The `version` field is the contract
+ * for forward-compat: when `totem sync` parses an unknown version (higher
+ * than the runner supports), it warns-and-skips that pack entirely
+ * (ADR-104 § Decision 4).
+ */
+export declare const HooksYamlSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodNumber;
+    hooks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        trigger: z.ZodObject<{
+            tool: z.ZodString;
+            pattern: z.ZodEffects<z.ZodString, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            tool: string;
+            pattern: string;
+        }, {
+            tool: string;
+            pattern: string;
+        }>;
+        check: z.ZodObject<{
+            pattern: z.ZodEffects<z.ZodString, string, string>;
+            type: z.ZodEnum<["reject-if-match", "reject-if-no-match"]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        }, {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        }>;
+        message: z.ZodString;
+        recoveryHint: z.ZodOptional<z.ZodString>;
+        verification_shadow: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }, {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    hooks: {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }[];
+    version: number;
+}, {
+    hooks: {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }[];
+    version: number;
+}>, {
+    hooks: {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }[];
+    version: number;
+}, {
+    hooks: {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }[];
+    version: number;
+}>;
+export type HooksYaml = z.infer<typeof HooksYamlSchema>;
+export declare const COMPILED_HOOKS_SCHEMA_VERSION: 1;
+/**
+ * A compiled hook rule carries provenance (`packId`) so rejection messages
+ * can name `<packId>/<ruleId>` (ADR-104 § Decision 1) and so staleness
+ * checks can scope per-pack.
+ */
+export declare const CompiledHookRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    trigger: z.ZodObject<{
+        tool: z.ZodString;
+        pattern: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        pattern: string;
+    }, {
+        tool: string;
+        pattern: string;
+    }>;
+    check: z.ZodObject<{
+        pattern: z.ZodEffects<z.ZodString, string, string>;
+        type: z.ZodEnum<["reject-if-match", "reject-if-no-match"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    }, {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    }>;
+    message: z.ZodString;
+    recoveryHint: z.ZodOptional<z.ZodString>;
+    verification_shadow: z.ZodOptional<z.ZodUnknown>;
+} & {
+    packId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    check: {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    };
+    message: string;
+    id: string;
+    trigger: {
+        tool: string;
+        pattern: string;
+    };
+    packId: string;
+    recoveryHint?: string | undefined;
+    verification_shadow?: unknown;
+}, {
+    check: {
+        type: "reject-if-match" | "reject-if-no-match";
+        pattern: string;
+    };
+    message: string;
+    id: string;
+    trigger: {
+        tool: string;
+        pattern: string;
+    };
+    packId: string;
+    recoveryHint?: string | undefined;
+    verification_shadow?: unknown;
+}>;
+export type CompiledHookRule = z.infer<typeof CompiledHookRuleSchema>;
+/**
+ * Runtime-surface manifest produced by `totem sync` and read on every
+ * `totem hook run` invocation. The metadata fields are load-bearing for
+ * ADR-104 § Decision 3 (staleness detection):
+ *
+ * - `schemaVersion`: bumps on breaking structural change to this manifest
+ * - `compiledAt`: ISO 8601 timestamp of last compile
+ * - `sourcePackVersions`: pack name → version at compile time; compared
+ *   against package.json resolutions to emit `[totem:hook-stale]` warnings
+ *   when packs have updated since last compile
+ */
+export declare const CompiledHooksManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    compiledAt: z.ZodString;
+    sourcePackVersions: z.ZodRecord<z.ZodString, z.ZodString>;
+    hooks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        trigger: z.ZodObject<{
+            tool: z.ZodString;
+            pattern: z.ZodEffects<z.ZodString, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            tool: string;
+            pattern: string;
+        }, {
+            tool: string;
+            pattern: string;
+        }>;
+        check: z.ZodObject<{
+            pattern: z.ZodEffects<z.ZodString, string, string>;
+            type: z.ZodEnum<["reject-if-match", "reject-if-no-match"]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        }, {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        }>;
+        message: z.ZodString;
+        recoveryHint: z.ZodOptional<z.ZodString>;
+        verification_shadow: z.ZodOptional<z.ZodUnknown>;
+    } & {
+        packId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        packId: string;
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }, {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        packId: string;
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    hooks: {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        packId: string;
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }[];
+    schemaVersion: 1;
+    compiledAt: string;
+    sourcePackVersions: Record<string, string>;
+}, {
+    hooks: {
+        check: {
+            type: "reject-if-match" | "reject-if-no-match";
+            pattern: string;
+        };
+        message: string;
+        id: string;
+        trigger: {
+            tool: string;
+            pattern: string;
+        };
+        packId: string;
+        recoveryHint?: string | undefined;
+        verification_shadow?: unknown;
+    }[];
+    schemaVersion: 1;
+    compiledAt: string;
+    sourcePackVersions: Record<string, string>;
+}>;
+export type CompiledHooksManifest = z.infer<typeof CompiledHooksManifestSchema>;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/hook/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/hook/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;GAUG;AAEH,QAAA,MAAM,mBAAmB,sDAAoD,CAAC;AAE9E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AA4EhE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,yBAAyB,EAAG,CAAU,CAAC;AAEpD;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBxB,CAAC;AAEL,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,6BAA6B,EAAG,CAAU,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/hook/schema.js

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+import { isRegexSafe } from '@mmnto/totem';
+/**
+ * Hook rule schemas for the bot-pack wiring engine (ADR-104).
+ *
+ * Two surfaces:
+ * - `HooksYamlSchema` describes a pack's `hooks.yaml` (authoring surface).
+ * - `CompiledHooksManifestSchema` describes `.totem/compiled-hooks.json`
+ *   (runtime surface produced by `totem sync` from installed packs).
+ *
+ * The compiled manifest carries the staleness metadata required by
+ * ADR-104 § Decision 3: schemaVersion + compiledAt + sourcePackVersions.
+ */
+const HookCheckTypeSchema = z.enum(['reject-if-match', 'reject-if-no-match']);
+/**
+ * Generous upper bound on pack-supplied regex pattern length. Real rules in
+ * the existing corpus run well under 200 chars; 512 leaves headroom while
+ * capping the attack surface against deliberately-bloated inputs. Bounding
+ * length at the schema layer also makes ReDoS-style worst-case payloads
+ * easier to reason about (the engine never compiles 10KB patterns).
+ */
+const MAX_PATTERN_LENGTH = 512;
+/**
+ * Validate that a regex pattern is well-formed AND safe from catastrophic
+ * backtracking. Runs at parse time (Tenet 4: don't fail open silently on
+ * invalid input). Three layers, gated in order with `fatal: true` so an
+ * earlier failure short-circuits — otherwise Zod would run `isRegexSafe`
+ * against an unbounded-length or syntactically-invalid input:
+ *
+ * 1. Bounded length (`MAX_PATTERN_LENGTH`) — caps the attack surface against
+ *    deliberately-bloated patterns.
+ * 2. Syntactically valid (compiles via `new RegExp`).
+ * 3. Free of nested unbounded-quantifier shapes via `safe-regex2`
+ *    (re-exported from core as `isRegexSafe`). Without this, a pack
+ *    publishing a pattern like `(a+)+$` would hang `evaluateHook` on
+ *    crafted tool-call payloads. Pack-supplied patterns come from
+ *    third-party npm, so ReDoS rejection at parse time is load-bearing
+ *    for the engine's availability guarantee.
+ */
+const RegexPatternSchema = z.string().superRefine((p, ctx) => {
+    if (p.length < 1) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'pattern must not be empty',
+            fatal: true,
+        });
+        return z.NEVER;
+    }
+    if (p.length > MAX_PATTERN_LENGTH) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `pattern exceeds ${MAX_PATTERN_LENGTH}-char limit`,
+            fatal: true,
+        });
+        return z.NEVER;
+    }
+    try {
+        new RegExp(p);
+        // totem-context: intentional — catch below is throw-as-control-flow for regex validation
+    }
+    catch {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'pattern is not a valid regular expression',
+            fatal: true,
+        });
+        return z.NEVER;
+    }
+    if (!isRegexSafe(p)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'pattern has catastrophic-backtracking risk (ReDoS); reshape to bounded quantifiers',
+            fatal: true,
+        });
+        return z.NEVER;
+    }
+});
+const HookTriggerSchema = z.object({
+    tool: z.string().min(1),
+    pattern: RegexPatternSchema,
+});
+const HookCheckSchema = z.object({
+    pattern: RegexPatternSchema,
+    type: HookCheckTypeSchema,
+});
+/**
+ * Authoring-surface schema for a single hook rule in a pack's `hooks.yaml`.
+ *
+ * The optional `recoveryHint` field (ADR-104 § Decision 1) gives agents the
+ * WHAT-INSTEAD on a block — recommended but not required in V1. Adoption
+ * tracked toward a V2 upgrade-to-required trigger (>80% of published rules
+ * carry it, OR an empirically-observed retry-loop incident).
+ *
+ * The `verification_shadow` field is reserved for the Spine Rule
+ * classification path (ADR-104 § Convergence + Q1 binding). In V1 the engine
+ * MUST warn-and-ignore any verification_shadow on a hook rule (hooks are
+ * Interpretive Rule class — no formal verification obligation). Schema
+ * accepts it permissively so future Spine-Rule promotion does not require
+ * a schema break.
+ */
+export const HookRuleSchema = z.object({
+    id: z.string().min(1),
+    trigger: HookTriggerSchema,
+    check: HookCheckSchema,
+    message: z.string().min(1),
+    recoveryHint: z.string().optional(),
+    verification_shadow: z.unknown().optional(),
+});
+export const HOOKS_YAML_SCHEMA_VERSION = 1;
+/**
+ * Per-pack `hooks.yaml` file shape. The `version` field is the contract
+ * for forward-compat: when `totem sync` parses an unknown version (higher
+ * than the runner supports), it warns-and-skips that pack entirely
+ * (ADR-104 § Decision 4).
+ */
+export const HooksYamlSchema = z
+    .object({
+    version: z.number().int().positive(),
+    hooks: z.array(HookRuleSchema),
+})
+    .superRefine((data, ctx) => {
+    // Duplicate hook ids within a single pack would make the
+    // `<packId>/<ruleId>` provenance in rejection messages (ADR-104 § Decision 1)
+    // ambiguous. Enforce uniqueness at parse time so a misauthored pack fails
+    // on load rather than producing non-deterministic rejection trails.
+    const seen = new Set();
+    data.hooks.forEach((hook, i) => {
+        if (seen.has(hook.id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `Duplicate hook id within pack: ${hook.id}`,
+                path: ['hooks', i, 'id'],
+            });
+        }
+        seen.add(hook.id);
+    });
+});
+export const COMPILED_HOOKS_SCHEMA_VERSION = 1;
+/**
+ * A compiled hook rule carries provenance (`packId`) so rejection messages
+ * can name `<packId>/<ruleId>` (ADR-104 § Decision 1) and so staleness
+ * checks can scope per-pack.
+ */
+export const CompiledHookRuleSchema = HookRuleSchema.extend({
+    packId: z.string().min(1),
+});
+/**
+ * Runtime-surface manifest produced by `totem sync` and read on every
+ * `totem hook run` invocation. The metadata fields are load-bearing for
+ * ADR-104 § Decision 3 (staleness detection):
+ *
+ * - `schemaVersion`: bumps on breaking structural change to this manifest
+ * - `compiledAt`: ISO 8601 timestamp of last compile
+ * - `sourcePackVersions`: pack name → version at compile time; compared
+ *   against package.json resolutions to emit `[totem:hook-stale]` warnings
+ *   when packs have updated since last compile
+ */
+export const CompiledHooksManifestSchema = z.object({
+    schemaVersion: z.literal(COMPILED_HOOKS_SCHEMA_VERSION),
+    compiledAt: z.string().datetime(),
+    sourcePackVersions: z.record(z.string(), z.string()),
+    hooks: z.array(CompiledHookRuleSchema),
+});
+//# sourceMappingURL=schema.js.map

package/dist/hook/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/hook/schema.ts"],"names":[],"mappings":"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"}

package/dist/hook/schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schema.test.d.ts.map

package/dist/hook/schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.test.d.ts","sourceRoot":"","sources":["../../src/hook/schema.test.ts"],"names":[],"mappings":""}