agent-contracts 0.11.1 → 0.11.3

package/dist/index.d.ts

@@ -97,29 +97,31 @@ type Artifact = z.infer<typeof ArtifactSchema>;
 declare const MatcherSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"command_regex">;
     pattern: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$loose>, z.ZodObject<{
     type: z.ZodLiteral<"content_regex">;
     pattern: z.ZodString;
     file_glob: z.ZodOptional<z.ZodString>;
     exclude_glob: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
+}, z.core.$loose>, z.ZodObject<{
     type: z.ZodLiteral<"file_glob">;
     pattern: z.ZodString;
-}, z.core.$strip>], "type">;
+    exclude_glob: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>], "type">;
 type Matcher = z.infer<typeof MatcherSchema>;
 declare const CheckSchema: z.ZodObject<{
     matcher: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"command_regex">;
         pattern: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$loose>, z.ZodObject<{
         type: z.ZodLiteral<"content_regex">;
         pattern: z.ZodString;
         file_glob: z.ZodOptional<z.ZodString>;
         exclude_glob: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
+    }, z.core.$loose>, z.ZodObject<{
         type: z.ZodLiteral<"file_glob">;
         pattern: z.ZodString;
-    }, z.core.$strip>], "type">>;
+        exclude_glob: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "type">>;
     script: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
@@ -134,6 +136,7 @@ declare const BindingOutputSchema: z.ZodObject<{
     }>>;
     group_by: z.ZodOptional<z.ZodString>;
     executable: z.ZodOptional<z.ZodBoolean>;
+    skip_empty: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 type BindingOutput = z.infer<typeof BindingOutputSchema>;
 declare const ReportingSchema: z.ZodObject<{
@@ -151,15 +154,16 @@ declare const SoftwareBindingSchema: z.ZodObject<{
             matcher: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 type: z.ZodLiteral<"command_regex">;
                 pattern: z.ZodString;
-            }, z.core.$strip>, z.ZodObject<{
+            }, z.core.$loose>, z.ZodObject<{
                 type: z.ZodLiteral<"content_regex">;
                 pattern: z.ZodString;
                 file_glob: z.ZodOptional<z.ZodString>;
                 exclude_glob: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>, z.ZodObject<{
+            }, z.core.$loose>, z.ZodObject<{
                 type: z.ZodLiteral<"file_glob">;
                 pattern: z.ZodString;
-            }, z.core.$strip>], "type">>;
+                exclude_glob: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>], "type">>;
             script: z.ZodOptional<z.ZodString>;
             message: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>;
@@ -174,6 +178,7 @@ declare const SoftwareBindingSchema: z.ZodObject<{
         }>>;
         group_by: z.ZodOptional<z.ZodString>;
         executable: z.ZodOptional<z.ZodBoolean>;
+        skip_empty: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$loose>>>;
     reporting: z.ZodOptional<z.ZodObject<{
         commands: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -944,6 +949,7 @@ declare const RenderTargetSchema: z.ZodObject<{
     output: z.ZodString;
     include: z.ZodOptional<z.ZodArray<z.ZodString>>;
     exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skip_empty: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type RenderTarget = z.infer<typeof RenderTargetSchema>;
 declare const AgentContractsConfigSchema: z.ZodObject<{
@@ -967,6 +973,7 @@ declare const AgentContractsConfigSchema: z.ZodObject<{
         output: z.ZodString;
         include: z.ZodOptional<z.ZodArray<z.ZodString>>;
         exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skip_empty: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     bindings: z.ZodDefault<z.ZodArray<z.ZodString>>;
     active_guardrail_policy: z.ZodOptional<z.ZodString>;
@@ -979,6 +986,7 @@ interface ResolvedRenderTarget {
     output: string;
     include?: string[];
     exclude?: string[];
+    skip_empty?: boolean;
 }
 interface ResolvedConfig {
     dsl: string;

package/dist/index.js

@@ -50485,17 +50485,18 @@ import { z as z3 } from "zod";
 var CommandRegexMatcherSchema = z3.object({
   type: z3.literal("command_regex"),
   pattern: z3.string()
-});
+}).passthrough();
 var ContentRegexMatcherSchema = z3.object({
   type: z3.literal("content_regex"),
   pattern: z3.string(),
   file_glob: z3.string().optional(),
   exclude_glob: z3.string().optional()
-});
+}).passthrough();
 var FileGlobMatcherSchema = z3.object({
   type: z3.literal("file_glob"),
-  pattern: z3.string()
-});
+  pattern: z3.string(),
+  exclude_glob: z3.string().optional()
+}).passthrough();
 var MatcherSchema = z3.discriminatedUnion("type", [
   CommandRegexMatcherSchema,
   ContentRegexMatcherSchema,
@@ -50512,7 +50513,8 @@ var BindingOutputSchema = z3.object({
   inline_template: z3.string().optional(),
   mode: z3.enum(["write", "patch"]).default("write"),
   group_by: z3.string().optional(),
-  executable: z3.boolean().optional()
+  executable: z3.boolean().optional(),
+  skip_empty: z3.boolean().optional()
 }).passthrough().refine(
   (data) => !(data.template && data.inline_template),
   { message: "template and inline_template are mutually exclusive" }
@@ -52827,7 +52829,7 @@ async function spectralLint(dslObject) {
 }
 
 // src/renderer/renderer.ts
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { readFile as readFile2, writeFile, mkdir, unlink } from "fs/promises";
 import { dirname as dirname3 } from "path";
 import Handlebars from "handlebars";
 
@@ -53958,6 +53960,15 @@ function buildEntityContext(dsl, context, entityId) {
 async function loadTemplate(templatePath) {
   return readFile2(templatePath, "utf8");
 }
+function isEffectivelyEmpty(output) {
+  return output.trim().length === 0;
+}
+async function removeIfExists(filePath) {
+  try {
+    await unlink(filePath);
+  } catch {
+  }
+}
 async function renderFromConfig(dsl, renderTargets) {
   const outputFiles = [];
   for (const target of renderTargets) {
@@ -53966,6 +53977,10 @@ async function renderFromConfig(dsl, renderTargets) {
     if (target.context === "system") {
       const ctx = buildSystemContext(dsl);
       const output = compiled(ctx);
+      if (target.skip_empty && isEffectivelyEmpty(output)) {
+        await removeIfExists(target.output);
+        continue;
+      }
       await mkdir(dirname3(target.output), { recursive: true });
       await writeFile(target.output, output, "utf8");
       outputFiles.push(target.output);
@@ -53977,6 +53992,10 @@ async function renderFromConfig(dsl, renderTargets) {
         const ctx = buildEntityContext(dsl, target.context, entityId);
         const output = compiled(ctx);
         const outputPath = expandOutputPath(target.output, target.context, entityId);
+        if (target.skip_empty && isEffectivelyEmpty(output)) {
+          await removeIfExists(outputPath);
+          continue;
+        }
         await mkdir(dirname3(outputPath), { recursive: true });
         await writeFile(outputPath, output, "utf8");
         outputFiles.push(outputPath);
@@ -53985,6 +54004,26 @@ async function renderFromConfig(dsl, renderTargets) {
   }
   return outputFiles;
 }
+async function fileExists(filePath) {
+  try {
+    await readFile2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkExpectedVsExisting(expected, outputPath, skipEmpty, diffs) {
+  if (skipEmpty && isEffectivelyEmpty(expected)) {
+    return fileExists(outputPath).then((exists) => {
+      if (exists) diffs.push(outputPath);
+    });
+  }
+  return readFile2(outputPath, "utf8").then((existing) => {
+    if (existing !== expected) diffs.push(outputPath);
+  }).catch(() => {
+    diffs.push(outputPath);
+  });
+}
 async function checkDriftFromConfig(dsl, renderTargets) {
   const diffs = [];
   for (const target of renderTargets) {
@@ -53993,12 +54032,7 @@ async function checkDriftFromConfig(dsl, renderTargets) {
     if (target.context === "system") {
       const ctx = buildSystemContext(dsl);
       const expected = compiled(ctx);
-      try {
-        const existing = await readFile2(target.output, "utf8");
-        if (existing !== expected) diffs.push(target.output);
-      } catch {
-        diffs.push(target.output);
-      }
+      await checkExpectedVsExisting(expected, target.output, target.skip_empty, diffs);
     } else {
       const section = getDslSection(dsl, target.context);
       const allIds = Object.keys(section);
@@ -54007,12 +54041,7 @@ async function checkDriftFromConfig(dsl, renderTargets) {
         const ctx = buildEntityContext(dsl, target.context, entityId);
         const expected = compiled(ctx);
         const outputPath = expandOutputPath(target.output, target.context, entityId);
-        try {
-          const existing = await readFile2(outputPath, "utf8");
-          if (existing !== expected) diffs.push(outputPath);
-        } catch {
-          diffs.push(outputPath);
-        }
+        await checkExpectedVsExisting(expected, outputPath, target.skip_empty, diffs);
       }
     }
   }
@@ -54054,7 +54083,8 @@ var RenderTargetSchema = z16.object({
   context: ContextTypeSchema,
   output: z16.string(),
   include: z16.array(z16.string()).optional(),
-  exclude: z16.array(z16.string()).optional()
+  exclude: z16.array(z16.string()).optional(),
+  skip_empty: z16.boolean().optional()
 }).refine(
   (data) => !(data.include && data.exclude),
   { message: "include and exclude are mutually exclusive" }
@@ -54086,7 +54116,7 @@ var ConfigLoadError = class extends Error {
   }
   filePath;
 };
-async function fileExists(filePath) {
+async function fileExists2(filePath) {
   try {
     await access(filePath);
     return true;
@@ -54097,7 +54127,7 @@ async function fileExists(filePath) {
 async function loadConfig(configPath) {
   const isExplicit = configPath !== void 0;
   const targetPath = resolve4(configPath ?? DEFAULT_CONFIG_NAME);
-  if (!await fileExists(targetPath)) {
+  if (!await fileExists2(targetPath)) {
     if (isExplicit) {
       throw new ConfigLoadError(
         `Config file not found: ${targetPath}`,
@@ -54298,7 +54328,7 @@ ${issues}`,
 }
 
 // src/guardrail-generator/generator.ts
-import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, chmod } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, chmod, unlink as unlink2 } from "fs/promises";
 import { resolve as resolve6, dirname as dirname6 } from "path";
 import Handlebars2 from "handlebars";
 
@@ -54472,6 +54502,7 @@ async function generateGuardrails(options) {
         });
         continue;
       }
+      const shouldSkipEmpty = outputDef.skip_empty === true;
       if (outputDef.group_by) {
         const groupField = outputDef.group_by;
         const groups = /* @__PURE__ */ new Map();
@@ -54491,6 +54522,15 @@ async function generateGuardrails(options) {
           const compiled = Handlebars2.compile(templateContent, { noEscape: true });
           const output = compiled(groupCtx);
           const groupTarget = resolve6(targetPath, groupKey);
+          if (shouldSkipEmpty && output.trim().length === 0) {
+            if (!dryRun) {
+              try {
+                await unlink2(groupTarget);
+              } catch {
+              }
+            }
+            continue;
+          }
           if (!dryRun) {
             await mkdir2(dirname6(groupTarget), { recursive: true });
             await writeFile2(groupTarget, output, "utf8");
@@ -54503,14 +54543,23 @@ async function generateGuardrails(options) {
       } else {
         const compiled = Handlebars2.compile(templateContent, { noEscape: true });
         const output = compiled(ctx);
-        if (!dryRun) {
-          await mkdir2(dirname6(targetPath), { recursive: true });
-          await writeFile2(targetPath, output, "utf8");
-          if (outputDef.executable) {
-            await chmod(targetPath, 493);
+        if (shouldSkipEmpty && output.trim().length === 0) {
+          if (!dryRun) {
+            try {
+              await unlink2(targetPath);
+            } catch {
+            }
+          }
+        } else {
+          if (!dryRun) {
+            await mkdir2(dirname6(targetPath), { recursive: true });
+            await writeFile2(targetPath, output, "utf8");
+            if (outputDef.executable) {
+              await chmod(targetPath, 493);
+            }
           }
+          outputFiles.push(targetPath);
         }
-        outputFiles.push(targetPath);
       }
     }
   }