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

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.20";
+    WAIRON_VERSION = "5.1.1-dev.21";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -15185,7 +15185,8 @@ __export(provision_exports, {
   listDirectChainedSubprojects: () => listDirectChainedSubprojects,
   moveSubsystemProject: () => moveSubsystemProject,
   provisionProject: () => provisionProject,
-  renameComponent: () => renameComponent
+  renameComponent: () => renameComponent,
+  renameMethod: () => renameMethod
 });
 function defaultProjectConfig(name, now) {
   return {
@@ -15518,6 +15519,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")) {
@@ -15539,6 +15549,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 = (list2) => Array.isArray(list2) ? list2 : [];
     const rewriteEach = (list2, position) => {
       entries(list2).forEach((_, i) => rewrite(list2, i, position));
@@ -15549,30 +15568,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 method2 of raw.methods) {
         for (const param of entries(method2?.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 method2 of raw.methods) {
         for (const step of entries(method2?.narrative)) {
+          rewriteMethod(step, "targetMethod", step?.targetComponent);
           rewrite(step, "targetComponent", "component");
           const source = step?.auth?.from;
           if (typeof source === "string" && source.startsWith(COMPONENT_AUTH_SOURCE)) {
@@ -15585,8 +15606,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");
     }
@@ -15706,7 +15726,101 @@ function removeSpecFile(file, id) {
     fs13.rmdirSync(dir);
   }
 }
-var fs13, path17, 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 fs13, path17, COMPONENT_AUTH_SOURCE, METHOD_NAME, PROSE_FIELDS;
 var init_provision = __esm({
   "src/core/provision.ts"() {
     "use strict";
@@ -15720,6 +15834,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"
+    ]);
   }
 });
 
@@ -25058,6 +25184,9 @@ function loadProjectConfig5() {
 function renameComponent2(componentId, newId) {
   return renameComponent(componentId, newId);
 }
+function renameMethod2(componentId, methodName, newName, pinSymbol) {
+  return renameMethod(componentId, methodName, newName, pinSymbol);
+}
 function qualifiedComponentId(id) {
   const ids = loadComponentSpecs().map((c) => c.id);
   if (ids.includes(id)) return id;
@@ -25661,6 +25790,26 @@ NOTICE:
       }
     }
   );
+  reg(
+    server,
+    "sdd_rename_method",
+    {
+      description: "Rename a contract method and retarget every reference to it in the bound tree. The method moves on every interface of the component that declares it \u2014 its name, and the name inside its signature \u2014 and on the implementations of those contracts, carrying narrative, sourcePath, symbol, detail, intent and findings unchanged; an implementation that declared no symbol is pinned to the old name unless pinSymbol is false, so the function it already binds to keeps binding. Narrative call, register and dispatch steps naming this component and method, dispatch-table bindings and lifecycle entrypoints are retargeted. Prose is never rewritten and a gRPC endpoint binding keeps its wire method \u2014 renaming a contract method must not silently rename an RPC; both are reported as mentions. Refuses, writing nothing: a component that does not exist (component-missing), one inside a chained subproject (chained-component \u2014 rename its method from that project's own root), a new name that is not a camel-case identifier (invalid-name), a method the component does not declare (method-missing), and a name a moving contract already declares (name-taken). Returns the specs the method moved in, the specs retargeted, the specs whose prose still names it, and the pinned symbol when one was set.",
+      inputSchema: {
+        id: import_zod11.z.string().describe("The component whose method is renamed (namespaced if needed)"),
+        method: import_zod11.z.string().describe("The method name as it stands"),
+        newName: import_zod11.z.string().describe("Its new name: a camel-case identifier"),
+        pinSymbol: import_zod11.z.boolean().optional().describe("Whether an implementation that declares no symbol is pinned to the old name so its function still binds; true when omitted")
+      }
+    },
+    ({ id, method: method2, newName, pinSymbol }) => {
+      try {
+        return json(renameMethod2(qualifiedComponentId(id), method2, newName, pinSymbol));
+      } catch (e) {
+        return errText(String(e));
+      }
+    }
+  );
   const componentInput = {
     id: import_zod11.z.string().describe("Lowercase identifier for the component"),
     name: import_zod11.z.string().describe("Human-readable display name"),
@@ -26507,6 +26656,7 @@ var init_server = __esm({
       "sdd_externalize_subsystem",
       "sdd_internalize_subsystem",
       "sdd_rename_component",
+      "sdd_rename_method",
       "sdd_add_component",
       "sdd_define_interface",
       "sdd_set_endpoints",
@@ -41842,7 +41992,8 @@ var WRITE_TOOL_PREFIXES = [
   "sdd_initialize_",
   "sdd_externalize_",
   "sdd_internalize_",
-  "sdd_move_"
+  "sdd_move_",
+  "sdd_rename_"
 ];
 var READ_TOOL_PREFIXES = ["sdd_get_", "sdd_validate_"];
 var READ_TOOL_NAMES = /* @__PURE__ */ new Set([
@@ -41853,12 +42004,8 @@ var READ_TOOL_NAMES = /* @__PURE__ */ new Set([
   "validateTopology",
   "getProjectConfig"
 ]);
-var WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "sdd_rename_component"
-]);
 function requiredDataPlaneCapability(toolName) {
   if (READ_TOOL_NAMES.has(toolName) || READ_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) return "project:read";
-  if (WRITE_TOOL_NAMES.has(toolName) || WRITE_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) return "project:write";
   return "project:write";
 }
 var TREE_SCOPED_HOST_TOOLS = /* @__PURE__ */ new Set([
@@ -41868,7 +42015,7 @@ var TREE_SCOPED_HOST_TOOLS = /* @__PURE__ */ new Set([
 function toolScope(toolName) {
   if (PROJECT_RECORD_TOOLS.has(toolName)) return "record";
   if (TREE_SCOPED_HOST_TOOLS.has(toolName)) return "tree";
-  if (READ_TOOL_NAMES.has(toolName) || READ_TOOL_PREFIXES.some((p) => toolName.startsWith(p)) || WRITE_TOOL_NAMES.has(toolName) || WRITE_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) {
+  if (READ_TOOL_NAMES.has(toolName) || READ_TOOL_PREFIXES.some((p) => toolName.startsWith(p)) || WRITE_TOOL_PREFIXES.some((p) => toolName.startsWith(p))) {
     return "tree";
   }
   return void 0;