@wairon/cli 5.1.1-dev.20 → 5.1.1-dev.21

package/dist/index.js

@@ -1113,7 +1113,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.20";
+    WAIRON_VERSION = "5.1.1-dev.21";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -19930,6 +19930,15 @@ function componentIdsUnder(dir) {
   }
   return ids;
 }
+function specKind(raw) {
+  if ("componentType" in raw) return "component";
+  if ("parentSystem" in raw) return "subsystem";
+  if ("vision" in raw) return "system";
+  if ("component" in raw && Array.isArray(raw.methods)) return "interface";
+  if ("contract" in raw && Array.isArray(raw.methods)) return "implementation";
+  if ("kind" in raw && Array.isArray(raw.fields)) return "type";
+  return void 0;
+}
 function rewriteRefFields(specsDir, remap, excludeDir) {
   const rewritten = [];
   for (const file of listFilesRecursive(specsDir, ".yaml")) {
@@ -19951,6 +19960,15 @@ function rewriteRefFields(specsDir, remap, excludeDir) {
         changed = true;
       }
     };
+    const rewriteMethod = (holder, key, owner) => {
+      const name = holder?.[key];
+      if (typeof name !== "string" || typeof owner !== "string") return;
+      const next = remap(name, "method", owner);
+      if (next !== name) {
+        holder[key] = next;
+        changed = true;
+      }
+    };
     const entries = (list) => Array.isArray(list) ? list : [];
     const rewriteEach = (list, position) => {
       entries(list).forEach((_, i) => rewrite(list, i, position));
@@ -19961,30 +19979,32 @@ function rewriteRefFields(specsDir, remap, excludeDir) {
         rewrite(published, "interface", "interface");
       }
     };
-    let kind;
-    if ("componentType" in raw) {
-      kind = "component";
+    const kind = specKind(raw);
+    if (kind === "component") {
       rewriteEach(raw.dependsOn, "component");
       rewriteEach(raw.owns, "component");
-      for (const binding of entries(raw.dispatch)) rewrite(binding, "component", "component");
-    } else if ("parentSystem" in raw) {
-      kind = "subsystem";
-      for (const entrypoint of entries(raw.lifecycle)) rewrite(entrypoint, "component", "component");
+      for (const binding of entries(raw.dispatch)) {
+        rewriteMethod(binding, "method", binding?.component);
+        rewrite(binding, "component", "component");
+      }
+    } else if (kind === "subsystem") {
+      for (const entrypoint of entries(raw.lifecycle)) {
+        rewriteMethod(entrypoint, "method", entrypoint?.component);
+        rewrite(entrypoint, "component", "component");
+      }
       rewritePublished(raw.publicInterfaces);
-    } else if ("vision" in raw) {
-      kind = "system";
+    } else if (kind === "system") {
       rewritePublished(raw.publicInterfaces);
-    } else if ("component" in raw && Array.isArray(raw.methods)) {
-      kind = "interface";
+    } else if (kind === "interface") {
       rewrite(raw, "component", "component");
       for (const method of raw.methods) {
         for (const param of entries(method?.params)) rewrite(param, "type", "type");
       }
-    } else if ("contract" in raw && Array.isArray(raw.methods)) {
-      kind = "implementation";
+    } else if (kind === "implementation") {
       rewrite(raw, "contract", "interface");
       for (const method of raw.methods) {
         for (const step of entries(method?.narrative)) {
+          rewriteMethod(step, "targetMethod", step?.targetComponent);
           rewrite(step, "targetComponent", "component");
           const source = step?.auth?.from;
           if (typeof source === "string" && source.startsWith(COMPONENT_AUTH_SOURCE)) {
@@ -19997,8 +20017,7 @@ function rewriteRefFields(specsDir, remap, excludeDir) {
           }
         }
       }
-    } else if ("kind" in raw && Array.isArray(raw.fields)) {
-      kind = "type";
+    } else if (kind === "type") {
       rewrite(raw, "componentClass", "entity-class");
       for (const field of raw.fields) rewrite(field, "type", "type");
     }
@@ -20118,7 +20137,101 @@ function removeSpecFile(file, id) {
     fs14.rmdirSync(dir);
   }
 }
-var fs14, path20, COMPONENT_AUTH_SOURCE;
+function renameMethod(componentId, methodName, newName, pinSymbol) {
+  const component = loadComponentSpec(componentId);
+  if (!component) {
+    throw new WaironError(`component-missing: no component has the id "${componentId}".`);
+  }
+  if (componentId.includes("::")) {
+    throw new WaironError(
+      `chained-component: "${componentId}" lives in a chained subproject; rename its method from that project's own root.`
+    );
+  }
+  if (!METHOD_NAME.test(newName)) {
+    throw new WaironError(`invalid-name: "${newName}" is not a camel-case identifier.`);
+  }
+  const contracts = loadInterfaceSpecs().filter((i) => i.component === componentId);
+  const moving = contracts.filter((i) => i.methods.some((m) => m.name === methodName));
+  if (moving.length === 0) {
+    throw new WaironError(`method-missing: no contract of "${componentId}" declares the method "${methodName}".`);
+  }
+  const taken = moving.filter((i) => i.methods.some((m) => m.name === newName)).map((i) => `"${i.id}"`);
+  if (taken.length > 0) {
+    throw new WaironError(`name-taken: ${taken.join(", ")} already declares a method under the name "${newName}".`);
+  }
+  const implementations = loadImplementationSpecs();
+  const movingContracts = new Set(moving.map((i) => i.id));
+  const renamed = [];
+  for (const contract of moving) {
+    saveInterfaceSpec({
+      ...contract,
+      methods: contract.methods.map((m) => m.name === methodName ? { ...m, name: newName, signature: renameInSignature(m.signature, methodName, newName) } : m)
+    });
+    renamed.push(contract.id);
+  }
+  let pinnedSymbol;
+  for (const implementation of implementations) {
+    if (!movingContracts.has(implementation.contract)) continue;
+    const realization = implementation.methods.find((m) => m.name === methodName);
+    if (!realization) continue;
+    const pin = realization.symbol === void 0 && pinSymbol !== false;
+    if (pin) pinnedSymbol = methodName;
+    saveImplementationSpec({
+      ...implementation,
+      methods: implementation.methods.map((m) => m.name === methodName ? { ...m, name: newName, ...pin ? { symbol: methodName } : {} } : m)
+    });
+    renamed.push(implementation.id);
+  }
+  invalidateSpecCache();
+  const specsDir = aiPathsAt(getProjectRoot()).specsDir();
+  const rewritten = rewriteRefFields(specsDir, (ref, position, owner) => position === "method" && owner === componentId && ref === methodName ? newName : ref).map((spec) => spec.id);
+  const mentions = collectMentions(specsDir, methodName, moving);
+  return {
+    component: componentId,
+    from: methodName,
+    to: newName,
+    renamed,
+    rewritten,
+    mentions,
+    ...pinnedSymbol ? { pinnedSymbol } : {}
+  };
+}
+function renameInSignature(signature, from, to) {
+  return signature.replace(identifierPattern(from), to);
+}
+function collectMentions(specsDir, methodName, moved) {
+  const mentions = /* @__PURE__ */ new Set();
+  for (const contract of moved) {
+    const wireBound = contract.methods.some((m) => {
+      const endpoint = m.endpoint;
+      return endpoint?.transport === "gRPC" && endpoint.method === methodName;
+    });
+    if (wireBound) mentions.add(contract.id);
+  }
+  const named = identifierPattern(methodName);
+  const namesMethod = (value) => {
+    if (Array.isArray(value)) return value.some(namesMethod);
+    if (!value || typeof value !== "object") return false;
+    return Object.entries(value).some(([key, nested]) => typeof nested === "string" ? PROSE_FIELDS.has(key) && named.test(nested) : namesMethod(nested));
+  };
+  for (const file of listFilesRecursive(specsDir, ".yaml")) {
+    let raw;
+    try {
+      raw = readYamlFile(file);
+    } catch {
+      continue;
+    }
+    if (!raw || typeof raw !== "object") continue;
+    const kind = specKind(raw);
+    if (!kind || !namesMethod(raw)) continue;
+    mentions.add(kind === "system" ? "system" : String(raw.id));
+  }
+  return [...mentions];
+}
+function identifierPattern(methodName) {
+  return new RegExp(`(?<![A-Za-z0-9_])${methodName}(?![A-Za-z0-9_])`);
+}
+var fs14, path20, COMPONENT_AUTH_SOURCE, METHOD_NAME, PROSE_FIELDS;
 var init_provision = __esm({
   "src/core/provision.ts"() {
     "use strict";
@@ -20132,6 +20245,18 @@ var init_provision = __esm({
     init_errors();
     init_models();
     COMPONENT_AUTH_SOURCE = "component:";
+    METHOD_NAME = /^[a-z][a-zA-Z0-9]*$/;
+    PROSE_FIELDS = /* @__PURE__ */ new Set([
+      "description",
+      "intent",
+      "summary",
+      "condition",
+      "over",
+      "outcome",
+      "error",
+      "note",
+      "caller"
+    ]);
   }
 });
 
@@ -24701,6 +24826,7 @@ __export(src_exports, {
   removePackSelection: () => removePackSelection,
   removeSnapshot: () => removeSnapshot,
   renameComponent: () => renameComponent,
+  renameMethod: () => renameMethod,
   renderDiagram: () => renderDiagram,
   renderDomainsDoc: () => renderDomainsDoc,
   renderTemplateInstructions: () => renderTemplateInstructions,
@@ -25419,6 +25545,7 @@ function loadProjectConfig4() {
   removePackSelection,
   removeSnapshot,
   renameComponent,
+  renameMethod,
   renderDiagram,
   renderDomainsDoc,
   renderTemplateInstructions,