agent-contracts 0.22.5 → 0.22.7

package/cli-contract.yaml

@@ -3,7 +3,7 @@ cliContracts: 0.1.0
 
 info:
   title: agent-contracts CLI
-  version: 0.22.3
+  version: 0.22.6
   description: >-
     Declarative YAML DSL toolkit for defining, validating, and rendering
     multi-agent development workflows. Provides static validation,

package/dist/cli.js

@@ -48896,8 +48896,195 @@ import { resolve as resolve8, dirname as dirname8 } from "path";
 // src/generated/cli-contract/program.ts
 import { Command } from "commander";
 
+// src/generated/cli-contract/policy-runtime.ts
+var RISK_ORDER = {
+  low: 0,
+  medium: 1,
+  high: 2,
+  critical: 3
+};
+function maxRiskLevel(...levels) {
+  let max = "low";
+  for (const level of levels) {
+    if (RISK_ORDER[level] > RISK_ORDER[max]) {
+      max = level;
+    }
+  }
+  return max;
+}
+function isOptionActive(definition, value, specified) {
+  const schemaType = definition.schema?.type;
+  if (schemaType === "boolean") {
+    return value === true;
+  }
+  if (definition.repeatable) {
+    return specified && Array.isArray(value) && value.length > 0;
+  }
+  return specified && value != null;
+}
+function derivePolicy(input) {
+  const sideEffects = /* @__PURE__ */ new Set();
+  const reads = [];
+  const writes = [];
+  const networkEffects = [];
+  const riskLevels = [];
+  let executionMode;
+  let explicitConfirmation;
+  if (input.commandEffects) {
+    const ce2 = input.commandEffects;
+    riskLevels.push(ce2.riskLevel ?? "low");
+    if (ce2.writes) {
+      sideEffects.add("file_write");
+      for (const w2 of ce2.writes) {
+        writes.push({
+          kind: "semantic",
+          target: w2.target,
+          description: w2.description,
+          overwrite: w2.overwrite,
+          destructive: w2.destructive,
+          ...w2.idempotent !== void 0 ? { idempotent: w2.idempotent } : {},
+          ...w2.idempotencyKey ? { idempotencyKey: w2.idempotencyKey } : {},
+          ...w2.idempotentNote ? { idempotentNote: w2.idempotentNote } : {},
+          source: `command:${input.commandId}`
+        });
+      }
+    }
+    if (ce2.reads) {
+      for (const r3 of ce2.reads) {
+        reads.push({
+          kind: "semantic",
+          target: r3.target,
+          description: r3.description,
+          source: `command:${input.commandId}`
+        });
+      }
+    }
+    if (ce2.network) {
+      sideEffects.add("network");
+      if (typeof ce2.network === "object") {
+        networkEffects.push({
+          ...ce2.network.description ? { description: ce2.network.description } : {},
+          ...ce2.network.domains ? { domains: ce2.network.domains } : {},
+          ...ce2.network.idempotent !== void 0 ? { idempotent: ce2.network.idempotent } : {},
+          ...ce2.network.idempotencyKey ? { idempotencyKey: ce2.network.idempotencyKey } : {},
+          ...ce2.network.idempotentNote ? { idempotentNote: ce2.network.idempotentNote } : {},
+          source: `command:${input.commandId}`
+        });
+      }
+    }
+    if (ce2.executionMode) {
+      executionMode = ce2.executionMode;
+    }
+    if (ce2.requiresConfirmation !== void 0) {
+      explicitConfirmation = ce2.requiresConfirmation;
+    }
+  }
+  for (const [optName, optInput] of Object.entries(input.options)) {
+    const { definition, value, specified } = optInput;
+    const active = isOptionActive(definition, value, specified);
+    if (!active) continue;
+    if (definition.file) {
+      const filePath = typeof value === "string" ? value : void 0;
+      const mode = definition.file.mode;
+      if (mode === "read" || mode === "readWrite") {
+        reads.push({
+          kind: "option-file",
+          option: optName,
+          path: filePath,
+          source: `option:${optName}`
+        });
+      }
+      if (mode === "write" || mode === "append" || mode === "readWrite") {
+        sideEffects.add("file_write");
+        writes.push({
+          kind: "option-file",
+          option: optName,
+          path: filePath,
+          mode,
+          source: `option:${optName}`
+        });
+      }
+    }
+    if (definition.effects) {
+      const eff = definition.effects;
+      riskLevels.push(eff.riskLevel ?? "low");
+      if (eff.writes) {
+        sideEffects.add("file_write");
+        for (const w2 of eff.writes) {
+          writes.push({
+            kind: "semantic",
+            target: w2.target,
+            description: w2.description,
+            overwrite: w2.overwrite,
+            destructive: w2.destructive,
+            ...w2.idempotent !== void 0 ? { idempotent: w2.idempotent } : {},
+            ...w2.idempotencyKey ? { idempotencyKey: w2.idempotencyKey } : {},
+            ...w2.idempotentNote ? { idempotentNote: w2.idempotentNote } : {},
+            source: `option:${optName}`
+          });
+        }
+      }
+      if (eff.reads) {
+        for (const r3 of eff.reads) {
+          reads.push({
+            kind: "semantic",
+            target: r3.target,
+            description: r3.description,
+            source: `option:${optName}`
+          });
+        }
+      }
+      if (eff.network) {
+        sideEffects.add("network");
+        if (typeof eff.network === "object") {
+          networkEffects.push({
+            ...eff.network.description ? { description: eff.network.description } : {},
+            ...eff.network.domains ? { domains: eff.network.domains } : {},
+            ...eff.network.idempotent !== void 0 ? { idempotent: eff.network.idempotent } : {},
+            ...eff.network.idempotencyKey ? { idempotencyKey: eff.network.idempotencyKey } : {},
+            ...eff.network.idempotentNote ? { idempotentNote: eff.network.idempotentNote } : {},
+            source: `option:${optName}`
+          });
+        }
+      }
+      if (eff.executionMode && !executionMode) {
+        executionMode = eff.executionMode;
+      }
+      if (eff.requiresConfirmation !== void 0 && explicitConfirmation === void 0) {
+        explicitConfirmation = eff.requiresConfirmation;
+      }
+    }
+  }
+  const finalRiskLevel = riskLevels.length > 0 ? maxRiskLevel(...riskLevels) : "low";
+  const requiresConfirmation = explicitConfirmation ?? (finalRiskLevel === "high" || finalRiskLevel === "critical");
+  let requiresSecrets;
+  if (input.env) {
+    const secrets = [];
+    for (const [envName, envVar] of Object.entries(input.env)) {
+      if (envVar.sensitive) {
+        secrets.push(envName);
+      }
+    }
+    if (secrets.length > 0) {
+      requiresSecrets = secrets;
+    }
+  }
+  const semanticWrites = writes.filter((w2) => w2.kind === "semantic");
+  const idempotent = semanticWrites.every((w2) => w2.idempotent === true) && networkEffects.every((n3) => n3.idempotent === true);
+  return {
+    riskLevel: finalRiskLevel,
+    requiresConfirmation,
+    idempotent,
+    sideEffects: [...sideEffects],
+    reads,
+    writes,
+    ...networkEffects.length > 0 ? { network: networkEffects } : {},
+    ...executionMode ? { executionMode } : {},
+    ...requiresSecrets ? { requiresSecrets } : {}
+  };
+}
+
 // src/generated/cli-contract/policy.ts
-import { derivePolicy, isOptionActive } from "cli-contracts/policy";
 var commandDefinitions = {
   "resolve": {
     "options": [
@@ -50876,24 +51063,39 @@ function mergeDsl(base, project) {
 
 // src/resolver/resolve.ts
 import { dirname as dirname3, resolve as resolvePath } from "path";
-async function resolve4(projectDirOrFile) {
-  const absPath = resolvePath(projectDirOrFile);
-  const projectResult = await loadDsl(absPath);
-  const projectData = projectResult.data;
-  const extendsValue = projectData["extends"];
+async function resolveExtendsChain(data, filePath, seen) {
+  const extendsValue = data["extends"];
   if (typeof extendsValue !== "string") {
-    return {
-      data: projectData,
-      projectPath: projectResult.filePath
-    };
+    return { data, basePaths: [] };
   }
-  const projectDir = dirname3(projectResult.filePath);
+  const projectDir = dirname3(filePath);
   const baseResult = await resolveBase(extendsValue, projectDir);
-  const merged = mergeDsl(baseResult.data, projectData);
+  const basePath = baseResult.filePath;
+  if (seen.has(basePath)) {
+    throw new BaseResolveError(
+      `Circular extends detected: ${basePath}`
+    );
+  }
+  seen.add(basePath);
+  const { data: resolvedBase, basePaths: ancestorPaths } = await resolveExtendsChain(baseResult.data, basePath, seen);
+  const merged = mergeDsl(resolvedBase, data);
   return {
     data: merged,
+    basePaths: [...ancestorPaths, basePath]
+  };
+}
+async function resolve4(projectDirOrFile) {
+  const absPath = resolvePath(projectDirOrFile);
+  const projectResult = await loadDsl(absPath);
+  const { data, basePaths } = await resolveExtendsChain(
+    projectResult.data,
+    projectResult.filePath,
+    /* @__PURE__ */ new Set()
+  );
+  return {
+    data,
     projectPath: projectResult.filePath,
-    basePath: baseResult.filePath
+    basePaths
   };
 }