@aaac/contracts 0.1.13 → 0.1.15

package/dist/cli/index.js

@@ -3,18 +3,26 @@ import {
   ComponentCompileError,
   ComponentParseError,
   ComponentValidationError,
+  GOVERNANCE_LOCK_PATH,
   RefResolutionError,
+  SCAFFOLD_PROJECT_YAML,
   compileComponent,
   compileComponentFile,
+  copyCLIBinary,
   generateAll,
+  loadHookBindings,
+  loadInitConfig,
+  materializeHooks,
   parseComponentFile,
+  readGovernanceLock,
+  unmaterializeHooks,
   validateComponent,
   writeGeneratedFiles
-} from "../chunk-MWZFJ2VL.js";
+} from "../chunk-F57V745S.js";
 
 // src/cli/index.ts
 import { readFileSync } from "fs";
-import { dirname as dirname3, resolve as resolve3 } from "path";
+import { dirname as dirname2, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../node_modules/commander/lib/error.js
@@ -3800,356 +3808,10 @@ function createProgram(handlers2, version) {
 }
 
 // src/cli/handlers.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
-import { stringify as stringifyYaml } from "yaml";
-
-// src/cli/governance.ts
-import { createHash } from "crypto";
 import { existsSync } from "fs";
-import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, writeFile } from "fs/promises";
 import { dirname, join, resolve } from "path";
-import { parse as parseYaml } from "yaml";
-import { z } from "zod";
-var MANAGED_BLOCK_START = "# >>> aaac-governance:managed (do not edit) >>>";
-var MANAGED_BLOCK_END = "# <<< aaac-governance:managed <<<";
-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()
-}).optional();
-var BindingsObservabilitySchema = z.object({
-  event_mapping: z.string().optional(),
-  recorder: z.string().optional()
-}).optional();
-var BindingsSchema = z.object({
-  observability: BindingsObservabilitySchema,
-  hooks: z.array(z.string()).optional()
-}).optional();
-var InitProjectConfigSchema = z.object({
-  environments: EnvironmentsSchema,
-  bindings: BindingsSchema
-});
-async function loadInitConfig(configPath) {
-  const absPath = resolve(configPath);
-  const raw = await readFile(absPath, "utf8");
-  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, "\\$&");
-}
-function createManagedBlockRegex() {
-  return new RegExp(
-    `${escapeRegex(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegex(MANAGED_BLOCK_END)}\\n?`,
-    "g"
-  );
-}
-function buildManagedBlock(blockContent) {
-  return `${MANAGED_BLOCK_START}
-${blockContent.trimEnd()}
-${MANAGED_BLOCK_END}
-`;
-}
-function injectManagedBlock(existingContent, blockContent) {
-  const managedBlock = buildManagedBlock(blockContent);
-  const re = createManagedBlockRegex();
-  if (re.test(existingContent)) {
-    return existingContent.replace(createManagedBlockRegex(), managedBlock);
-  }
-  const trimmed = existingContent.replace(/\s+$/, "");
-  if (trimmed.length === 0) {
-    return `#!/bin/sh
-${managedBlock}`;
-  }
-  const separator = trimmed.endsWith("\n") ? "" : "\n";
-  return `${trimmed}${separator}${managedBlock}`;
-}
-function removeManagedBlock(existingContent) {
-  if (!existingContent.includes(MANAGED_BLOCK_START)) {
-    return existingContent;
-  }
-  const withoutBlock = existingContent.replace(createManagedBlockRegex(), "");
-  const meaningful = withoutBlock.split("\n").filter((line) => {
-    const t = line.trim();
-    return t.length > 0 && t !== "#!/bin/sh" && t !== "#!/bin/bash";
-  });
-  if (meaningful.length === 0) {
-    return "";
-  }
-  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 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);
-  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 [
-    { event: "beforeSubmitPrompt", command: `${recorder} beforeSubmitPrompt` },
-    { event: "afterShellExecution", command: `${recorder} afterShellExecution` }
-  ];
-}
-async function ensureParentDir(filePath) {
-  await mkdir(dirname(filePath), { recursive: true });
-}
-async function readTextFileIfExists(filePath) {
-  if (!existsSync(filePath)) return void 0;
-  return readFile(filePath, "utf8");
-}
-async function writeGovernanceLock(projectRoot, entries) {
-  const lockPath = join(projectRoot, GOVERNANCE_LOCK_PATH);
-  const lock = {
-    materialized_at: (/* @__PURE__ */ new Date()).toISOString(),
-    entries
-  };
-  await ensureParentDir(lockPath);
-  await writeFile(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf8");
-  return GOVERNANCE_LOCK_PATH;
-}
-async function readGovernanceLock(projectRoot) {
-  const lockPath = join(projectRoot, GOVERNANCE_LOCK_PATH);
-  if (!existsSync(lockPath)) return void 0;
-  const raw = await readFile(lockPath, "utf8");
-  if (!raw.trim()) return void 0;
-  return JSON.parse(raw);
-}
-async function materializeHooks(options) {
-  const projectRoot = resolve(options.projectRoot);
-  const result = { materialized: [], lockEntries: [] };
-  const recorder = options.observabilityBinding?.recorder ?? DEFAULT_RECORDER;
-  if (options.environments.git?.hooks?.length) {
-    for (const hookName of options.environments.git.hooks) {
-      const relPath = join(".git/hooks", hookName);
-      const absPath = join(projectRoot, relPath);
-      const blockContent = buildGitHookBlock(
-        hookName,
-        recorder,
-        options.hookCommands?.[hookName]
-      );
-      const existing = await readTextFileIfExists(absPath) ?? "";
-      const updated = injectManagedBlock(existing, blockContent);
-      let action = "unchanged";
-      if (!existsSync(absPath)) {
-        action = "created";
-      } else if (updated !== existing) {
-        action = "updated";
-      }
-      if (action !== "unchanged") {
-        await ensureParentDir(absPath);
-        await writeFile(absPath, updated, "utf8");
-        await chmod(absPath, 493);
-      }
-      result.materialized.push({ path: relPath, action });
-      result.lockEntries.push({ path: relPath, type: "git-hook" });
-    }
-  }
-  if (options.environments.cursor) {
-    const rawHooksJsonValue = options.environments.cursor.hooks_json;
-    const hooksJsonPath = rawHooksJsonValue ? resolve(projectRoot, rawHooksJsonValue) : join(projectRoot, DEFAULT_CURSOR_HOOKS_JSON);
-    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 = parseCursorHooksFile(existingRaw);
-    const merged = mergeCursorHooks(existing, newEntries);
-    const serialized = serializeCursorHooksFile(merged);
-    let action = "unchanged";
-    if (!existsSync(hooksJsonPath)) {
-      action = "created";
-    } else if (serialized !== existingRaw) {
-      action = "updated";
-    }
-    if (action !== "unchanged") {
-      await ensureParentDir(hooksJsonPath);
-      await writeFile(hooksJsonPath, serialized, "utf8");
-    }
-    result.materialized.push({ path: relPath, action });
-    result.lockEntries.push({ path: relPath, type: "cursor-hook" });
-  }
-  if (result.lockEntries.length > 0) {
-    const lockExisted = existsSync(join(projectRoot, GOVERNANCE_LOCK_PATH));
-    await writeGovernanceLock(projectRoot, result.lockEntries);
-    result.materialized.push({
-      path: GOVERNANCE_LOCK_PATH,
-      action: lockExisted ? "updated" : "created"
-    });
-    result.lockEntries.push({ path: GOVERNANCE_LOCK_PATH, type: "generated" });
-  }
-  return result;
-}
-async function unmaterializeHooks(projectRoot, lockEntries) {
-  const root = resolve(projectRoot);
-  for (const entry of lockEntries) {
-    if (entry.type === "generated") {
-      const absPath = join(root, entry.path);
-      if (existsSync(absPath)) {
-        await writeFile(absPath, "", "utf8");
-      }
-      continue;
-    }
-    if (entry.type === "git-hook") {
-      const absPath = join(root, entry.path);
-      const existing = await readTextFileIfExists(absPath);
-      if (existing === void 0) continue;
-      const updated = removeManagedBlock(existing);
-      await writeFile(absPath, updated, "utf8");
-      continue;
-    }
-    if (entry.type === "cursor-hook") {
-      const absPath = join(root, entry.path);
-      const existingRaw = await readTextFileIfExists(absPath);
-      if (existingRaw === void 0) continue;
-      const existing = parseCursorHooksFile(existingRaw);
-      const commandsToRemove = buildDefaultCursorHooks(DEFAULT_RECORDER).map((h) => h.command);
-      const updated = removeCursorHooks(existing, commandsToRemove);
-      await writeFile(absPath, serializeCursorHooksFile(updated), "utf8");
-    }
-  }
-  const lockPath = join(root, GOVERNANCE_LOCK_PATH);
-  if (existsSync(lockPath)) {
-    await writeFile(lockPath, "", "utf8");
-  }
-}
-async function copyCLIBinary(srcPath, projectRoot, destRelPath = DEFAULT_BINARY_DEST) {
-  const dstPath = join(projectRoot, destRelPath);
-  const srcContent = await readFile(srcPath);
-  const srcHash = createHash("sha256").update(srcContent).digest("hex");
-  if (existsSync(dstPath)) {
-    const dstContent = await readFile(dstPath);
-    const dstHash = createHash("sha256").update(dstContent).digest("hex");
-    if (srcHash === dstHash) {
-      return { path: destRelPath, action: "unchanged" };
-    }
-    await writeFile(dstPath, srcContent);
-    await chmod(dstPath, 493);
-    return { path: destRelPath, action: "updated" };
-  }
-  await ensureParentDir(dstPath);
-  await writeFile(dstPath, srcContent);
-  await chmod(dstPath, 493);
-  return { path: destRelPath, action: "created" };
-}
-var SCAFFOLD_PROJECT_YAML = `schema: aaac/project/0.1
-
-# Uncomment and configure to enable git hook governance:
-#
-# environments:
-#   git:
-#     hooks: [pre-commit, pre-push, post-commit]
-#   cursor:
-#     hooks_json: .cursor/hooks.json
-#
-# bindings:
-#   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
+import { stringify as stringifyYaml } from "yaml";
 function formatError(err, file) {
   if (err instanceof ComponentParseError) {
     return err.message;
@@ -4177,10 +3839,10 @@ function resolveComponentPath(file) {
   if (!file) {
     fail("Error: component file path is required");
   }
-  return resolve2(file);
+  return resolve(file);
 }
 function defaultOutputDir(componentPath) {
-  return join2(dirname2(componentPath), "generated");
+  return join(dirname(componentPath), "generated");
 }
 function buildIntrospectionDump(ir) {
   const operations = {};
@@ -4215,10 +3877,10 @@ var handleCompile = async (file, options, parentOpts) => {
     const ir = await compileComponentFile(componentPath);
     const json = JSON.stringify(ir, null, 2);
     if (options.output) {
-      await writeFile2(resolve2(options.output), `${json}
+      await writeFile(resolve(options.output), `${json}
 `, "utf-8");
       if (!parentOpts.quiet) {
-        process.stdout.write(`Wrote IR to ${resolve2(options.output)}
+        process.stdout.write(`Wrote IR to ${resolve(options.output)}
 `);
       }
       return;
@@ -4233,7 +3895,7 @@ async function resolveEmbeddedDslData(ir, componentPath) {
   if (!ir.embeddedDslDir || !ir.implementation) {
     return void 0;
   }
-  const implPath = resolve2(dirname2(componentPath), ir.implementation);
+  const implPath = resolve(dirname(componentPath), ir.implementation);
   const { resolve: resolveDsl } = await import("agent-contracts");
   const dslResult = await resolveDsl(implPath);
   return dslResult.data;
@@ -4252,7 +3914,7 @@ function splitGeneratedFiles(files) {
 }
 var handleGenerate = async (file, options, parentOpts) => {
   const componentPath = resolveComponentPath(file);
-  const outputDir = resolve2(options.outputDir ?? defaultOutputDir(componentPath));
+  const outputDir = resolve(options.outputDir ?? defaultOutputDir(componentPath));
   const dryRun = Boolean(options.dryRun);
   try {
     const ir = await compileComponentFile(componentPath);
@@ -4277,10 +3939,10 @@ var handleGenerate = async (file, options, parentOpts) => {
           }
         }
         for (const generated of embedded) {
-          const embeddedDir = resolve2(dirname2(componentPath), generated.targetDir);
+          const embeddedDir = resolve(dirname(componentPath), generated.targetDir);
           const action = generated.overwrite ? "write" : "create";
           process.stdout.write(
-            `  ${action}: ${join2(embeddedDir, generated.path)} (embedded DSL)
+            `  ${action}: ${join(embeddedDir, generated.path)} (embedded DSL)
 `
           );
         }
@@ -4289,10 +3951,10 @@ var handleGenerate = async (file, options, parentOpts) => {
     }
     const result = await writeGeneratedFiles(main, outputDir);
     for (const generated of embedded) {
-      const embeddedDir = resolve2(dirname2(componentPath), generated.targetDir);
-      await mkdir2(embeddedDir, { recursive: true });
-      await writeFile2(join2(embeddedDir, generated.path), generated.content, "utf-8");
-      result.written.push(join2(generated.targetDir, generated.path));
+      const embeddedDir = resolve(dirname(componentPath), generated.targetDir);
+      await mkdir(embeddedDir, { recursive: true });
+      await writeFile(join(embeddedDir, generated.path), generated.content, "utf-8");
+      result.written.push(join(generated.targetDir, generated.path));
     }
     if (!parentOpts.quiet) {
       if (result.written.length > 0) {
@@ -4322,7 +3984,7 @@ var handleGenerate = async (file, options, parentOpts) => {
 };
 var handleValidate = async (file, options, parentOpts) => {
   const componentPath = resolveComponentPath(file);
-  const basePath = dirname2(componentPath);
+  const basePath = dirname(componentPath);
   try {
     const dsl = await parseComponentFile(componentPath);
     const ir = compileComponent(dsl, { basePath });
@@ -4356,24 +4018,24 @@ var handleIntrospect = async (file, options, _parentOpts) => {
 };
 var DEFAULT_PROJECT_YAML = "project.yaml";
 var handleInit = async (projectRoot, options, parentOpts) => {
-  const root = resolve2(projectRoot ?? ".");
+  const root = resolve(projectRoot ?? ".");
   const quiet = Boolean(parentOpts.quiet);
-  const projectYamlPath = join2(root, options.projectYaml ?? DEFAULT_PROJECT_YAML);
-  const srcBinary = resolve2(options.binaryPath ?? process.argv[1]);
+  const projectYamlPath = join(root, options.projectYaml ?? DEFAULT_PROJECT_YAML);
+  const srcBinary = resolve(options.binaryPath ?? process.argv[1]);
   const binaryResult = await copyCLIBinary(srcBinary, root);
   if (!quiet && binaryResult.action !== "unchanged") {
     process.stdout.write(`  ${binaryResult.action}: ${binaryResult.path}
 `);
   }
-  if (!existsSync2(projectYamlPath)) {
-    await writeFile2(projectYamlPath, SCAFFOLD_PROJECT_YAML, "utf8");
+  if (!existsSync(projectYamlPath)) {
+    await writeFile(projectYamlPath, SCAFFOLD_PROJECT_YAML, "utf8");
     if (!quiet) {
       process.stdout.write(`  created: ${DEFAULT_PROJECT_YAML}
 `);
     }
   }
-  const gitDir = join2(root, ".git");
-  if (!existsSync2(gitDir)) {
+  const gitDir = join(root, ".git");
+  if (!existsSync(gitDir)) {
     process.stderr.write(
       `Warning: .git/ not found in ${root}; skipping hook materialization
 `
@@ -4414,6 +4076,7 @@ var handleInit = async (projectRoot, options, parentOpts) => {
     projectRoot: root,
     environments: config.environments,
     observabilityBinding: config.bindings?.observability,
+    artifactContracts: config.artifacts,
     hookCommands
   });
   if (!quiet) {
@@ -4428,16 +4091,16 @@ var handleInit = async (projectRoot, options, parentOpts) => {
   }
 };
 var handleUpdate = async (projectRoot, options, parentOpts) => {
-  const root = resolve2(projectRoot ?? ".");
+  const root = resolve(projectRoot ?? ".");
   const quiet = Boolean(parentOpts.quiet);
-  const projectYamlPath = join2(root, options.projectYaml ?? DEFAULT_PROJECT_YAML);
-  if (!existsSync2(projectYamlPath)) {
+  const projectYamlPath = join(root, options.projectYaml ?? DEFAULT_PROJECT_YAML);
+  if (!existsSync(projectYamlPath)) {
     fail(
       `Error: ${DEFAULT_PROJECT_YAML} not found at ${root}. Run 'aaac init' first.`
     );
   }
-  const gitDir = join2(root, ".git");
-  if (!existsSync2(gitDir)) {
+  const gitDir = join(root, ".git");
+  if (!existsSync(gitDir)) {
     process.stderr.write(
       `Warning: .git/ not found in ${root}; skipping hook materialization
 `
@@ -4464,6 +4127,7 @@ var handleUpdate = async (projectRoot, options, parentOpts) => {
     projectRoot: root,
     environments: config.environments,
     observabilityBinding: config.bindings?.observability,
+    artifactContracts: config.artifacts,
     hookCommands
   });
   if (!quiet) {
@@ -4476,13 +4140,13 @@ var handleUpdate = async (projectRoot, options, parentOpts) => {
   }
 };
 var handleUninstall = async (projectRoot, _options, parentOpts) => {
-  const root = resolve2(projectRoot ?? ".");
+  const root = resolve(projectRoot ?? ".");
   const quiet = Boolean(parentOpts.quiet);
   const lock = await readGovernanceLock(root);
   if (!lock || lock.entries.length === 0) {
     if (!quiet) {
       process.stdout.write(
-        `Nothing to uninstall (no governance lock found at ${join2(root, GOVERNANCE_LOCK_PATH)})
+        `Nothing to uninstall (no governance lock found at ${join(root, GOVERNANCE_LOCK_PATH)})
 `
       );
     }
@@ -4505,9 +4169,9 @@ var handlers = {
 };
 
 // src/cli/index.ts
-var __dirname = dirname3(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  readFileSync(resolve3(__dirname, "../../package.json"), "utf8")
+  readFileSync(resolve2(__dirname, "../../package.json"), "utf8")
 );
 var program2 = createProgram(handlers, pkg.version);
 await program2.parseAsync();