@wairon/cli 5.1.1-dev.57 → 5.1.1-dev.58

package/dist/index.js

@@ -3578,6 +3578,7 @@ __export(src_exports, {
   deleteSubsystemSpec: () => deleteSubsystemSpec,
   deleteTypeSpec: () => deleteTypeSpec,
   deregisterPackRef: () => deregisterPackRef,
+  deriveExecutionProfile: () => deriveExecutionProfile,
   describeApprover: () => describeApprover,
   detectDomainCandidates: () => detectDomainCandidates,
   diagnoseProjectPacks: () => diagnoseProjectPacks,
@@ -3755,6 +3756,7 @@ __export(src_exports, {
   renderWaironGuide: () => renderWaironGuide,
   repairForeignStepFields: () => repairForeignStepFields,
   resolveAgentTopology: () => resolveAgentTopology,
+  resolveBudget: () => resolveBudget,
   resolveChainingParent: () => resolveChainingParent,
   resolveDomains: () => resolveDomains2,
   resolveExpectedOutputPaths: () => resolveExpectedOutputPaths,
@@ -11654,7 +11656,7 @@ function defaultTargetConfig(type) {
     enabled: true
   };
 }
-var WAIRON_VERSION = "5.1.1-dev.57";
+var WAIRON_VERSION = "5.1.1-dev.58";
 var GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 var ARCHITECT_AGENT_ID = "agent-architect";
 var ARCHITECT_TEMPLATE_ID = "architect";
@@ -17055,6 +17057,96 @@ var carriedDebtRule = {
   }
 };
 
+// src/core/rules/heuristic/method-cohesion.ts
+function groupsSharingCollaborators(calledBy) {
+  const parent = /* @__PURE__ */ new Map();
+  const find = (m) => {
+    let root = m;
+    while (parent.get(root) !== root) root = parent.get(root);
+    return root;
+  };
+  const union = (a, b) => {
+    const [ra, rb] = [find(a), find(b)];
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  const methods = [...calledBy.keys()];
+  for (const m of methods) parent.set(m, m);
+  for (let i = 0; i < methods.length; i++) {
+    for (let j = i + 1; j < methods.length; j++) {
+      const shares = [...calledBy.get(methods[i])].some((c) => calledBy.get(methods[j])?.has(c));
+      if (shares) union(methods[i], methods[j]);
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const m of methods) {
+    const root = find(m);
+    groups.set(root, [...groups.get(root) ?? [], m]);
+  }
+  return [...groups.values()];
+}
+function isForwardingMethod(narrative) {
+  let handoffs = 0;
+  for (const step of narrative) {
+    if (step.type === "call" || step.type === "dispatch") handoffs++;
+    else if (step.type !== "return") return false;
+  }
+  return handoffs === 1;
+}
+function isPureForwarder(methods) {
+  const narrated = methods.filter((m) => (m.narrative ?? []).length > 0);
+  return narrated.length > 0 && narrated.every((m) => isForwardingMethod(m.narrative ?? []));
+}
+function pureForwarderComponents(ctx) {
+  const realized = /* @__PURE__ */ new Map();
+  for (const impl of ctx.implementations) {
+    const intf = ctx.interfaceMap.get(impl.contract);
+    if (!intf) continue;
+    realized.set(intf.component, [...realized.get(intf.component) ?? [], ...impl.methods]);
+  }
+  return new Set([...realized].filter(([, methods]) => isPureForwarder(methods)).map(([id]) => id));
+}
+var methodCohesionRule = {
+  name: "method-cohesion",
+  description: "An Orchestrator's methods share collaborators; when they split into groups that call no component in common, the component holds more than one responsibility. Reported only where two or more groups each hold two or more methods, so a single specialized method is not a finding \u2014 and never on a pure forwarder, whose every narrated method is a single hand-off and whose responsibility therefore lives in what it forwards to.",
+  codes: [
+    { code: "INCOHESIVE_METHODS", defaultSeverity: "warning", summary: "Orchestrator's methods form two or more groups of two or more that share no called component" }
+  ],
+  check(ctx) {
+    const subjects = [];
+    for (const impl of ctx.implementations) {
+      const intf = ctx.interfaceMap.get(impl.contract);
+      const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
+      if (!comp || comp.componentType !== "Orchestrator") continue;
+      if (isPureForwarder(impl.methods)) continue;
+      const calledBy = /* @__PURE__ */ new Map();
+      for (const method of impl.methods) {
+        const reached = /* @__PURE__ */ new Set();
+        for (const step of method.narrative ?? []) {
+          if ((step.type === "call" || step.type === "dispatch") && step.targetComponent) reached.add(step.targetComponent);
+        }
+        if (reached.size > 0) calledBy.set(method.name, reached);
+      }
+      subjects.push({ implementation: impl, component: comp, calledBy });
+    }
+    for (const { component, calledBy } of subjects) {
+      if (calledBy.size < 2) continue;
+      const groups = groupsSharingCollaborators(calledBy).filter((g) => g.length >= 2);
+      if (groups.length < 2) continue;
+      const described = groups.map((g) => {
+        const collaborators = [...new Set(g.flatMap((m) => [...calledBy.get(m)]))].sort();
+        return `${g.join(", ")} (calling ${collaborators.join(", ")})`;
+      }).join("; ");
+      ctx.addIssue(
+        "warning",
+        "INCOHESIVE_METHODS",
+        `Orchestrator "${component.id}" holds ${groups.length} groups of methods that share no called component: ${described}. Split it along those groups, move the logic out until every method is a single hand-off (a pure forwarder is exempt), or acknowledge a deliberate facade with a reasoned lint.allow for INCOHESIVE_METHODS.`,
+        component.id,
+        ctx.isComponentDraft(component.id)
+      );
+    }
+  }
+};
+
 // src/core/rules/heuristic/coupling-health.ts
 var DEFAULT_GOD_COMPONENT_THRESHOLD = 8;
 var couplingRule = {
@@ -17064,7 +17156,7 @@ var couplingRule = {
     { code: "MUTUAL_SUBSYSTEM_DEPENDENCY", defaultSeverity: "warning", summary: "Subsystems depend on each other without a declared trusted link" },
     { code: "INVALID_TRUSTED_LINK", defaultSeverity: "error", summary: "trustedLinks references a non-existent subsystem" },
     { code: "UNUSED_TRUSTED_LINK", defaultSeverity: "warning", summary: "trustedLinks declares a peer no dependency actually reaches" },
-    { code: "GOD_COMPONENT", defaultSeverity: "warning", summary: "Component with excessive dependency fan-out" }
+    { code: "GOD_COMPONENT", defaultSeverity: "warning", summary: "Component with excessive dependency fan-out; not reported on a pure forwarder, whose every narrated method is a single hand-off" }
   ],
   check(ctx) {
     const subsystemDeps = /* @__PURE__ */ new Map();
@@ -17136,9 +17228,10 @@ var couplingRule = {
         );
       }
     }
+    const forwarders = pureForwarderComponents(ctx);
     for (const comp of ctx.components) {
       const threshold = ctx.complexityConfigFor(comp.subsystem)?.maxComponentDependencies ?? DEFAULT_GOD_COMPONENT_THRESHOLD;
-      if (comp.dependsOn.length > threshold) {
+      if (comp.dependsOn.length > threshold && !forwarders.has(comp.id)) {
         ctx.addIssue(
           "warning",
           "GOD_COMPONENT",
@@ -17730,7 +17823,7 @@ var complexityRule = {
     { code: "DESCRIPTION_TOO_SHORT", defaultSeverity: "warning", summary: "Description is shorter than the configured minimum length" },
     { code: "EXCESSIVE_METHODS", defaultSeverity: "warning", summary: "Interface declares more methods than the configured limit" },
     { code: "EXCESSIVE_METHOD_PARAMS", defaultSeverity: "warning", summary: "Interface method declares more parameters than the configured limit" },
-    { code: "EXCESSIVE_DEPENDENCIES", defaultSeverity: "warning", summary: "Component has more dependencies than the configured limit" },
+    { code: "EXCESSIVE_DEPENDENCIES", defaultSeverity: "warning", summary: "Component has more dependencies than the configured limit; not reported on a pure forwarder, whose fan-out is a routing table rather than knowledge" },
     { code: "EXCESSIVE_SUBSYSTEM_COMPONENTS", defaultSeverity: "warning", summary: "Subsystem has more direct components than the configured limit" }
   ],
   check(ctx) {
@@ -17750,6 +17843,7 @@ var complexityRule = {
         );
       }
     }
+    const forwarders = pureForwarderComponents(ctx);
     for (const comp of ctx.components) {
       const docConfig = ctx.documentationConfigFor(comp.subsystem);
       const complexityConfig = ctx.complexityConfigFor(comp.subsystem);
@@ -17763,7 +17857,7 @@ var complexityRule = {
         "Component",
         isDraft
       );
-      if (complexityConfig?.maxComponentDependencies !== void 0 && comp.dependsOn.length > complexityConfig.maxComponentDependencies) {
+      if (complexityConfig?.maxComponentDependencies !== void 0 && comp.dependsOn.length > complexityConfig.maxComponentDependencies && !forwarders.has(comp.id)) {
         ctx.addIssue(
           "warning",
           "EXCESSIVE_DEPENDENCIES",
@@ -18046,84 +18140,6 @@ var namingDisciplineRule = {
   }
 };
 
-// src/core/rules/heuristic/method-cohesion.ts
-function groupsSharingCollaborators(calledBy) {
-  const parent = /* @__PURE__ */ new Map();
-  const find = (m) => {
-    let root = m;
-    while (parent.get(root) !== root) root = parent.get(root);
-    return root;
-  };
-  const union = (a, b) => {
-    const [ra, rb] = [find(a), find(b)];
-    if (ra !== rb) parent.set(ra, rb);
-  };
-  const methods = [...calledBy.keys()];
-  for (const m of methods) parent.set(m, m);
-  for (let i = 0; i < methods.length; i++) {
-    for (let j = i + 1; j < methods.length; j++) {
-      const shares = [...calledBy.get(methods[i])].some((c) => calledBy.get(methods[j])?.has(c));
-      if (shares) union(methods[i], methods[j]);
-    }
-  }
-  const groups = /* @__PURE__ */ new Map();
-  for (const m of methods) {
-    const root = find(m);
-    groups.set(root, [...groups.get(root) ?? [], m]);
-  }
-  return [...groups.values()];
-}
-function isForwardingMethod(narrative) {
-  let handoffs = 0;
-  for (const step of narrative) {
-    if (step.type === "call" || step.type === "dispatch") handoffs++;
-    else if (step.type !== "return") return false;
-  }
-  return handoffs === 1;
-}
-var methodCohesionRule = {
-  name: "method-cohesion",
-  description: "An Orchestrator's methods share collaborators; when they split into groups that call no component in common, the component holds more than one responsibility. Reported only where two or more groups each hold two or more methods, so a single specialized method is not a finding \u2014 and never on a pure forwarder, whose every narrated method is a single hand-off and whose responsibility therefore lives in what it forwards to.",
-  codes: [
-    { code: "INCOHESIVE_METHODS", defaultSeverity: "warning", summary: "Orchestrator's methods form two or more groups of two or more that share no called component" }
-  ],
-  check(ctx) {
-    const subjects = [];
-    for (const impl of ctx.implementations) {
-      const intf = ctx.interfaceMap.get(impl.contract);
-      const comp = intf ? ctx.componentMap.get(intf.component) : void 0;
-      if (!comp || comp.componentType !== "Orchestrator") continue;
-      const narrated = impl.methods.filter((m) => (m.narrative ?? []).length > 0);
-      if (narrated.length > 0 && narrated.every((m) => isForwardingMethod(m.narrative ?? []))) continue;
-      const calledBy = /* @__PURE__ */ new Map();
-      for (const method of impl.methods) {
-        const reached = /* @__PURE__ */ new Set();
-        for (const step of method.narrative ?? []) {
-          if ((step.type === "call" || step.type === "dispatch") && step.targetComponent) reached.add(step.targetComponent);
-        }
-        if (reached.size > 0) calledBy.set(method.name, reached);
-      }
-      subjects.push({ implementation: impl, component: comp, calledBy });
-    }
-    for (const { component, calledBy } of subjects) {
-      if (calledBy.size < 2) continue;
-      const groups = groupsSharingCollaborators(calledBy).filter((g) => g.length >= 2);
-      if (groups.length < 2) continue;
-      const described = groups.map((g) => {
-        const collaborators = [...new Set(g.flatMap((m) => [...calledBy.get(m)]))].sort();
-        return `${g.join(", ")} (calling ${collaborators.join(", ")})`;
-      }).join("; ");
-      ctx.addIssue(
-        "warning",
-        "INCOHESIVE_METHODS",
-        `Orchestrator "${component.id}" holds ${groups.length} groups of methods that share no called component: ${described}. Split it along those groups, move the logic out until every method is a single hand-off (a pure forwarder is exempt), or acknowledge a deliberate facade with a reasoned lint.allow for INCOHESIVE_METHODS.`,
-        component.id,
-        ctx.isComponentDraft(component.id)
-      );
-    }
-  }
-};
-
 // src/core/rules/repository.ts
 var SDD_RULES = [
   hierarchyRule,
@@ -27388,6 +27404,7 @@ function loadProjectConfig4() {
   deleteSubsystemSpec,
   deleteTypeSpec,
   deregisterPackRef,
+  deriveExecutionProfile,
   describeApprover,
   detectDomainCandidates,
   diagnoseProjectPacks,
@@ -27565,6 +27582,7 @@ function loadProjectConfig4() {
   renderWaironGuide,
   repairForeignStepFields,
   resolveAgentTopology,
+  resolveBudget,
   resolveChainingParent,
   resolveDomains,
   resolveExpectedOutputPaths,