agent-contracts 0.22.6 → 0.22.8

package/dist/index.d.ts

@@ -854,7 +854,9 @@ declare const ReplaceOperatorSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ReplaceOperator = z.infer<typeof ReplaceOperatorSchema>;
 declare const RemoveOperatorSchema: z.ZodObject<{
-    $remove: z.ZodArray<z.ZodString>;
+    $remove: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>]>>;
 }, z.core.$strip>;
 type RemoveOperator = z.infer<typeof RemoveOperatorSchema>;
 type MergeableRecord<T> = Record<string, T> | {
@@ -869,7 +871,9 @@ type MergeableRecord<T> = Record<string, T> | {
 } | {
     $replace: unknown;
 } | {
-    $remove: string[];
+    $remove: (string | {
+        id: string;
+    })[];
 };
 
 declare const PolicyWhenSchema: z.ZodObject<{
@@ -1247,7 +1251,7 @@ declare function mergeDsl(base: AnyRecord, project: AnyRecord): AnyRecord;
 interface ResolveResult {
     data: Record<string, unknown>;
     projectPath: string;
-    basePath?: string;
+    basePaths: string[];
 }
 declare function resolve(projectDirOrFile: string): Promise<ResolveResult>;
 

package/dist/index.js

@@ -49451,7 +49451,7 @@ var InsertAfterOperatorSchema = z16.object({
 });
 var ReplaceOperatorSchema = z16.object({ $replace: z16.any() });
 var RemoveOperatorSchema = z16.object({
-  $remove: z16.array(z16.string())
+  $remove: z16.array(z16.union([z16.string(), z16.object({ id: z16.string() })]))
 });
 
 // src/loader/loader.ts
@@ -49863,10 +49863,13 @@ function hasOperator(obj) {
   }
   return null;
 }
-function findIndexById(arr, id) {
-  return arr.findIndex(
-    (item) => isRecord2(item) && item["id"] === id
-  );
+function findIndexByIdOrValue(arr, target) {
+  return arr.findIndex((item) => {
+    if (typeof item === "string") {
+      return item === target;
+    }
+    return isRecord2(item) && item["id"] === target;
+  });
 }
 function applyArrayMergeOperator(baseArray, operatorObj, path) {
   const op = hasOperator(operatorObj);
@@ -49884,7 +49887,7 @@ function applyArrayMergeOperator(baseArray, operatorObj, path) {
       const spec = operatorObj["$insert_after"];
       const target = spec["target"];
       const items = spec["items"];
-      const idx = findIndexById(baseArray, target);
+      const idx = findIndexByIdOrValue(baseArray, target);
       if (idx === -1) {
         throw new MergeError(
           `$insert_after target "${target}" not found in base at ${path}`
@@ -49899,7 +49902,28 @@ function applyArrayMergeOperator(baseArray, operatorObj, path) {
     }
     case "$remove": {
       const removeList = operatorObj["$remove"];
-      const idsToRemove = new Set(removeList.map((r3) => r3["id"]));
+      if (removeList.length === 0) {
+        return baseArray;
+      }
+      if (typeof removeList[0] === "string") {
+        const valuesToRemove = new Set(removeList);
+        const result2 = baseArray.filter((item) => {
+          if (typeof item === "string" && valuesToRemove.has(item)) {
+            valuesToRemove.delete(item);
+            return false;
+          }
+          return true;
+        });
+        if (valuesToRemove.size > 0) {
+          throw new MergeError(
+            `$remove values not found in base at ${path}: ${[...valuesToRemove].join(", ")}`
+          );
+        }
+        return result2;
+      }
+      const idsToRemove = new Set(
+        removeList.map((r3) => r3["id"])
+      );
       const result = baseArray.filter((item) => {
         if (isRecord2(item) && typeof item["id"] === "string") {
           const itemId = item["id"];
@@ -50090,24 +50114,39 @@ function mergeDsl(base, project) {
 
 // src/resolver/resolve.ts
 import { dirname as dirname2, resolve as resolvePath } from "path";
-async function resolve3(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 = dirname2(projectResult.filePath);
+  const projectDir = dirname2(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 resolve3(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
   };
 }