@aaac/contracts 0.1.12 → 0.1.13

package/dist/cli/index.js

@@ -3818,6 +3818,7 @@ var GOVERNANCE_LOCK_PATH = ".agent-logs/governance-manifest.lock";
 var DEFAULT_RECORDER = ".cursor/hooks/observ-record.sh";
 var DEFAULT_CURSOR_HOOKS_JSON = ".cursor/hooks.json";
 var DEFAULT_BINARY_DEST = "bin/aaac.js";
+var CURSOR_HOOKS_VERSION = 1;
 var EnvironmentsSchema = z.object({
   git: z.object({ hooks: z.array(z.string()).optional() }).optional(),
   cursor: z.object({ hooks_json: z.string().optional() }).optional()
@@ -3827,7 +3828,8 @@ var BindingsObservabilitySchema = z.object({
   recorder: z.string().optional()
 }).optional();
 var BindingsSchema = z.object({
-  observability: BindingsObservabilitySchema
+  observability: BindingsObservabilitySchema,
+  hooks: z.array(z.string()).optional()
 }).optional();
 var InitProjectConfigSchema = z.object({
   environments: EnvironmentsSchema,
@@ -3839,6 +3841,33 @@ async function loadInitConfig(configPath) {
   const parsed = parseYaml(raw);
   return InitProjectConfigSchema.parse(parsed ?? {});
 }
+var HookCommandSchema = z.object({
+  command: z.string(),
+  description: z.string().optional()
+});
+var HookBindingSchema = z.object({
+  hooks: z.record(z.string(), z.array(HookCommandSchema)).optional()
+});
+async function loadHookBindings(projectRoot, bindingPaths) {
+  const result = {};
+  if (!bindingPaths?.length) return result;
+  const root = resolve(projectRoot);
+  for (const bindingPath of bindingPaths) {
+    const absPath = resolve(root, bindingPath);
+    if (!existsSync(absPath)) continue;
+    const raw = await readFile(absPath, "utf8");
+    const parsed = HookBindingSchema.parse(parseYaml(raw) ?? {});
+    if (!parsed.hooks) continue;
+    for (const [hookName, commands] of Object.entries(parsed.hooks)) {
+      const list = result[hookName] ?? [];
+      for (const { command } of commands) {
+        if (!list.includes(command)) list.push(command);
+      }
+      result[hookName] = list;
+    }
+  }
+  return result;
+}
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -3882,15 +3911,77 @@ function removeManagedBlock(existingContent) {
   }
   return withoutBlock.replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "\n");
 }
+function parseCursorHooksFile(raw) {
+  if (!raw || !raw.trim()) {
+    return { version: CURSOR_HOOKS_VERSION, hooks: {} };
+  }
+  const parsed = JSON.parse(raw);
+  if (Array.isArray(parsed)) {
+    return flatEntriesToFile(
+      parsed.filter(
+        (entry) => entry !== null && typeof entry === "object" && typeof entry.event === "string" && typeof entry.command === "string"
+      )
+    );
+  }
+  if (parsed && typeof parsed === "object") {
+    const obj = parsed;
+    const version = typeof obj.version === "number" ? obj.version : CURSOR_HOOKS_VERSION;
+    const hooks = {};
+    const rawHooks = obj.hooks;
+    if (rawHooks && typeof rawHooks === "object" && !Array.isArray(rawHooks)) {
+      for (const [event, commands] of Object.entries(rawHooks)) {
+        if (Array.isArray(commands)) {
+          hooks[event] = commands.filter(
+            (c) => c !== null && typeof c === "object" && typeof c.command === "string"
+          );
+        }
+      }
+    }
+    return { version, hooks };
+  }
+  return { version: CURSOR_HOOKS_VERSION, hooks: {} };
+}
+function serializeCursorHooksFile(file) {
+  return JSON.stringify(file, null, 2) + "\n";
+}
+function flatEntriesToFile(entries) {
+  return mergeCursorHooks({ version: CURSOR_HOOKS_VERSION, hooks: {} }, entries);
+}
 function mergeCursorHooks(existing, newEntries) {
-  const byCommand = /* @__PURE__ */ new Map();
-  for (const entry of existing) byCommand.set(entry.command, entry);
-  for (const entry of newEntries) byCommand.set(entry.command, entry);
-  return Array.from(byCommand.values());
+  const hooks = {};
+  for (const [event, commands] of Object.entries(existing.hooks)) {
+    hooks[event] = commands.map((c) => ({ ...c }));
+  }
+  for (const entry of newEntries) {
+    const { event, ...command } = entry;
+    const list = hooks[event] ?? [];
+    const idx = list.findIndex((c) => c.command === command.command);
+    if (idx >= 0) {
+      list[idx] = command;
+    } else {
+      list.push(command);
+    }
+    hooks[event] = list;
+  }
+  return { version: existing.version ?? CURSOR_HOOKS_VERSION, hooks };
 }
 function removeCursorHooks(existing, commands) {
   const removeSet = new Set(commands);
-  return existing.filter((entry) => !removeSet.has(entry.command));
+  const hooks = {};
+  for (const [event, list] of Object.entries(existing.hooks)) {
+    const filtered = list.filter((c) => !removeSet.has(c.command));
+    if (filtered.length > 0) {
+      hooks[event] = filtered;
+    }
+  }
+  return { version: existing.version ?? CURSOR_HOOKS_VERSION, hooks };
+}
+function buildGitHookBlock(hookName, recorder, gateCommands = []) {
+  const lines = [`${recorder} ${hookName} "$@" || true`];
+  for (const command of gateCommands) {
+    lines.push(`${command} || exit 1`);
+  }
+  return lines.join("\n");
 }
 function buildDefaultCursorHooks(recorder) {
   return [
@@ -3930,7 +4021,11 @@ async function materializeHooks(options) {
     for (const hookName of options.environments.git.hooks) {
       const relPath = join(".git/hooks", hookName);
       const absPath = join(projectRoot, relPath);
-      const blockContent = `exec ${recorder} ${hookName} "$@"`;
+      const blockContent = buildGitHookBlock(
+        hookName,
+        recorder,
+        options.hookCommands?.[hookName]
+      );
       const existing = await readTextFileIfExists(absPath) ?? "";
       const updated = injectManagedBlock(existing, blockContent);
       let action = "unchanged";
@@ -3954,9 +4049,9 @@ async function materializeHooks(options) {
     const relPath = hooksJsonPath.startsWith(projectRoot + "/") ? hooksJsonPath.slice(projectRoot.length + 1) : DEFAULT_CURSOR_HOOKS_JSON;
     const newEntries = buildDefaultCursorHooks(recorder);
     const existingRaw = await readTextFileIfExists(hooksJsonPath);
-    const existing = existingRaw ? JSON.parse(existingRaw) : [];
+    const existing = parseCursorHooksFile(existingRaw);
     const merged = mergeCursorHooks(existing, newEntries);
-    const serialized = JSON.stringify(merged, null, 2) + "\n";
+    const serialized = serializeCursorHooksFile(merged);
     let action = "unchanged";
     if (!existsSync(hooksJsonPath)) {
       action = "created";
@@ -4003,14 +4098,10 @@ async function unmaterializeHooks(projectRoot, lockEntries) {
       const absPath = join(root, entry.path);
       const existingRaw = await readTextFileIfExists(absPath);
       if (existingRaw === void 0) continue;
-      const existing = JSON.parse(existingRaw);
+      const existing = parseCursorHooksFile(existingRaw);
       const commandsToRemove = buildDefaultCursorHooks(DEFAULT_RECORDER).map((h) => h.command);
       const updated = removeCursorHooks(existing, commandsToRemove);
-      await writeFile(
-        absPath,
-        updated.length === 0 ? "[]\n" : JSON.stringify(updated, null, 2) + "\n",
-        "utf8"
-      );
+      await writeFile(absPath, serializeCursorHooksFile(updated), "utf8");
     }
   }
   const lockPath = join(root, GOVERNANCE_LOCK_PATH);
@@ -4051,6 +4142,11 @@ var SCAFFOLD_PROJECT_YAML = `schema: aaac/project/0.1
 #   observability:
 #     event_mapping: ./bindings/observability.yaml
 #     recorder: aaac-observ
+#   hooks:
+#     # Each file declares gate commands per git hook; a non-zero exit
+#     # blocks the commit/push. Only hooks listed in environments.git.hooks
+#     # are materialized.
+#     - ./bindings/git.yaml
 `;
 
 // src/cli/handlers.ts
@@ -4313,10 +4409,12 @@ var handleInit = async (projectRoot, options, parentOpts) => {
     }
     return;
   }
+  const hookCommands = await loadHookBindings(root, config.bindings?.hooks);
   const result = await materializeHooks({
     projectRoot: root,
     environments: config.environments,
-    observabilityBinding: config.bindings?.observability
+    observabilityBinding: config.bindings?.observability,
+    hookCommands
   });
   if (!quiet) {
     for (const m of result.materialized) {
@@ -4361,10 +4459,12 @@ var handleUpdate = async (projectRoot, options, parentOpts) => {
     }
     return;
   }
+  const hookCommands = await loadHookBindings(root, config.bindings?.hooks);
   const result = await materializeHooks({
     projectRoot: root,
     environments: config.environments,
-    observabilityBinding: config.bindings?.observability
+    observabilityBinding: config.bindings?.observability,
+    hookCommands
   });
   if (!quiet) {
     for (const m of result.materialized) {