@wairon/cli 5.1.1-dev.4 → 5.1.1-dev.6

package/dist/cli/index.js

@@ -65,7 +65,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.4";
+    WAIRON_VERSION = "5.1.1-dev.6";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -16585,10 +16585,40 @@ var init_specs2 = __esm({
           return null;
         }
       }
+      /**
+       * Refuse a write that would land on a file already holding a DIFFERENT spec.
+       *
+       * In the nested layout a spec's path is derived from its parent — a component
+       * for an interface, a contract for an implementation — and the spec's own id
+       * is not part of it (see getInterfacePath / getImplementationPath, which take
+       * the id but ignore it once the parent resolves). So a second id bound to the
+       * same parent resolves to the SAME file.
+       *
+       * Left unguarded that is silent data loss, and doubly invisible: the caller's
+       * `existing` lookup is by the NEW id, finds nothing, and every re-author
+       * notice ("REMOVED …", the carry-forward seam) stays quiet. An agent renaming
+       * an interface by defining a new one destroys the old contract, its
+       * narratives and its lint.allows, and is told "Successfully defined".
+       */
+      assertPathHoldsNoOtherSpec(p, id, kind, parentLabel) {
+        if (!pathExists(p)) return;
+        let occupantId;
+        try {
+          occupantId = readYamlFile(p)?.id;
+        } catch {
+          return;
+        }
+        if (!occupantId) return;
+        if (occupantId === id || splitNamespace(occupantId).localId === splitNamespace(id).localId) return;
+        throw new Error(
+          `Cannot write ${kind} "${id}": ${parentLabel} is already ${kind === "interface" ? "served by" : "implemented by"} "${occupantId}" at ${path17.relative(this.rootDir, p)}, and both ids resolve to that one file. Re-author "${occupantId}" instead, or delete it first if you meant to replace it.`
+        );
+      }
       /** Returns non-fatal placement notices (see saveTypeSpec) — empty when there is nothing to clarify. */
       saveInterfaceSpec(spec, opts) {
         const notices = [];
         const p = this.getInterfacePath(spec.id, spec.component);
+        this.assertPathHoldsNoOtherSpec(p, spec.id, "interface", `component "${spec.component}"`);
         ensureDir(path17.dirname(p));
         const specToWrite = this.prepareInterfaceForWrite(spec);
         const existing = this.loadInterfaceSpec(spec.id);
@@ -16652,6 +16682,7 @@ var init_specs2 = __esm({
       saveImplementationSpec(spec, opts) {
         const notices = [];
         const p = this.getImplementationPath(spec.id, spec.contract);
+        this.assertPathHoldsNoOtherSpec(p, spec.id, "implementation", `contract "${spec.contract}"`);
         ensureDir(path17.dirname(p));
         const specToWrite = this.prepareImplementationForWrite(spec);
         const existing = this.loadImplementationSpec(spec.id);
@@ -16946,6 +16977,35 @@ var init_specs2 = __esm({
           }
           return refs;
         };
+        const normalizeIdentity = (k) => String(k ?? "").toLowerCase().replace(/[_\-\s]/g, "");
+        const assertDeltaMarkers = (item, label) => {
+          if (!item || typeof item !== "object") return;
+          if ("remove" in item && typeof item.remove !== "boolean") {
+            throw new Error(
+              `Refusing to update ${label}: "remove" must be the boolean true, got ${JSON.stringify(item.remove)}. A non-boolean is ignored, which would leave the element in place while reporting success.`
+            );
+          }
+          if ("action" in item && item.action !== "add" && item.action !== "delete") {
+            throw new Error(
+              `Refusing to update ${label}: unknown action ${JSON.stringify(item.action)} \u2014 expected "add" or "delete". An unknown verb is ignored, which would leave the element in place while reporting success.`
+            );
+          }
+        };
+        const assertUnmatchedIsAnAddition = (deltaItem, key, existingKeys, label) => {
+          if (deltaItem?.remove === true || deltaItem?.action === "delete") {
+            throw new Error(
+              `Refusing to delete ${label} "${String(key)}": nothing with that identity exists. ` + (existingKeys.length ? `Present: ${existingKeys.map(String).join(", ")}.` : "The collection is empty.")
+            );
+          }
+          const near = existingKeys.find(
+            (k) => String(k) !== String(key) && normalizeIdentity(k) === normalizeIdentity(key)
+          );
+          if (near !== void 0) {
+            throw new Error(
+              `Refusing to add ${label} "${String(key)}": "${String(near)}" already exists and differs only in case or separators. Use the existing identity to edit it, or pick a name that is not a near-duplicate.`
+            );
+          }
+        };
         const mergeNarrative = (existingSteps, deltaSteps) => {
           let steps = [...existingSteps];
           const sortedDeltas = [...deltaSteps].sort((a, b) => a.stepNumber - b.stepNumber);
@@ -17014,6 +17074,7 @@ var init_specs2 = __esm({
         const mergeMethods = (existingMethods, deltaMethods) => {
           const merged = [...existingMethods];
           for (const deltaMethod of deltaMethods) {
+            assertDeltaMarkers(deltaMethod, `method "${deltaMethod?.name}"`);
             const idx = merged.findIndex((m) => m.name === deltaMethod.name);
             if (idx !== -1) {
               if (deltaMethod.remove === true || deltaMethod.action === "delete") {
@@ -17033,9 +17094,8 @@ var init_specs2 = __esm({
                 };
               }
             } else {
-              if (deltaMethod.remove !== true && deltaMethod.action !== "delete") {
-                merged.push(deltaMethod);
-              }
+              assertUnmatchedIsAnAddition(deltaMethod, deltaMethod.name, merged.map((m) => m.name), "method");
+              merged.push(deltaMethod);
             }
           }
           return merged;
@@ -17043,6 +17103,7 @@ var init_specs2 = __esm({
         const mergeNamedArray = (existing, delta2) => {
           const merged = [...existing];
           for (const deltaItem of delta2) {
+            assertDeltaMarkers(deltaItem, `entry "${deltaItem?.name}"`);
             const idx = merged.findIndex((item) => item.name === deltaItem.name);
             if (idx !== -1) {
               if (deltaItem.remove === true || deltaItem.action === "delete") {
@@ -17055,9 +17116,8 @@ var init_specs2 = __esm({
                 };
               }
             } else {
-              if (deltaItem.remove !== true && deltaItem.action !== "delete") {
-                merged.push(deltaItem);
-              }
+              assertUnmatchedIsAnAddition(deltaItem, deltaItem.name, merged.map((i) => i.name), "entry");
+              merged.push(deltaItem);
             }
           }
           return merged;
@@ -17065,6 +17125,7 @@ var init_specs2 = __esm({
         const mergeKeyedArray = (existing, delta2, keyOf) => {
           const merged = [...existing];
           for (const deltaItem of delta2) {
+            assertDeltaMarkers(deltaItem, `entry "${keyOf(deltaItem)}"`);
             const idx = merged.findIndex((item) => keyOf(item) === keyOf(deltaItem));
             if (idx !== -1) {
               if (deltaItem.remove === true || deltaItem.action === "delete") {
@@ -17072,7 +17133,8 @@ var init_specs2 = __esm({
               } else {
                 merged[idx] = { ...merged[idx], ...deltaItem };
               }
-            } else if (deltaItem.remove !== true && deltaItem.action !== "delete") {
+            } else {
+              assertUnmatchedIsAnAddition(deltaItem, keyOf(deltaItem), merged.map(keyOf), "entry");
               merged.push(deltaItem);
             }
           }
@@ -17081,6 +17143,8 @@ var init_specs2 = __esm({
         const mergePublicInterfaces = (existing, delta2) => {
           const merged = [...existing];
           for (const deltaItem of delta2) {
+            const piKey = (i) => `${i?.component}.${i?.interface}`;
+            assertDeltaMarkers(deltaItem, `publicInterface "${piKey(deltaItem)}"`);
             const idx = merged.findIndex((item) => item.component === deltaItem.component && item.interface === deltaItem.interface);
             if (idx !== -1) {
               if (deltaItem.remove === true || deltaItem.action === "delete") {
@@ -17092,9 +17156,8 @@ var init_specs2 = __esm({
                 };
               }
             } else {
-              if (deltaItem.remove !== true && deltaItem.action !== "delete") {
-                merged.push(deltaItem);
-              }
+              assertUnmatchedIsAnAddition(deltaItem, piKey(deltaItem), merged.map(piKey), "publicInterface");
+              merged.push(deltaItem);
             }
           }
           return merged;
@@ -17135,11 +17198,22 @@ var init_specs2 = __esm({
           for (const deltaItem of delta2) {
             const key = identityKeyOf(field, deltaItem);
             const idx = key === null ? -1 : merged.findIndex((item) => identityKeyOf(field, item) === key);
+            assertDeltaMarkers(deltaItem, `${field} entry "${String(key)}"`);
             const isDelete = deltaItem?.remove === true || deltaItem?.action === "delete";
             if (idx !== -1) {
               if (isDelete) merged.splice(idx, 1);
               else merged[idx] = { ...merged[idx], ...deltaItem };
-            } else if (!isDelete) {
+            } else {
+              if (key !== null) {
+                assertUnmatchedIsAnAddition(
+                  deltaItem,
+                  key,
+                  merged.map((i) => identityKeyOf(field, i)).filter((k) => k !== null),
+                  field
+                );
+              } else if (isDelete) {
+                throw new Error(`Refusing to delete a ${field} entry with no resolvable identity.`);
+              }
               merged.push(deltaItem);
             }
           }