@wairon/cli 5.1.1-dev.46 → 5.1.1-dev.48

package/README.md

@@ -212,6 +212,12 @@ validation), js-yaml, the MCP SDK, and Vitest. Bundled with tsup.
 
 Actively developed. For bugs or questions, open an issue.
 
+Working on this repo (or delegating work in it) — see
+[CONTRIBUTING.md](CONTRIBUTING.md) for what this checkout does differently: line
+endings, the gate commands and their baselines, and the stale-MCP-server tell.
+The conventions that hold for *any* wairon project ship in the `sdd-implement`
+and `sdd-delegate` skills.
+
 ## License
 
 MIT

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.46";
+    WAIRON_VERSION = "5.1.1-dev.48";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     SUPPORTED_ALIASES = ["wai"];
     SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
@@ -2671,7 +2671,10 @@ function importBindingOf(facts, name) {
   return ownEntry(facts.importBindings, name);
 }
 function fieldTypesOf(facts, field) {
-  return ownEntry(facts.fieldTypes, field) ?? NO_FIELD_TYPES;
+  return ownEntry(facts.fieldTypes, field) ?? NO_DECLARED_TYPES;
+}
+function localTypesOf(facts, name) {
+  return ownEntry(facts.localTypes, name) ?? NO_DECLARED_TYPES;
 }
 function typeBindingOf(facts, name) {
   return ownEntry(facts.typeOnlyBindings, name) ?? ownEntry(facts.importBindings, name)?.from;
@@ -2700,12 +2703,12 @@ function resolveImport(fromFile, specifier, knownPaths) {
   }
   return void 0;
 }
-var path6, NO_FIELD_TYPES;
+var path6, NO_DECLARED_TYPES;
 var init_code_model = __esm({
   "src/models/code-model.ts"() {
     "use strict";
     path6 = __toESM(require("path"));
-    NO_FIELD_TYPES = [];
+    NO_DECLARED_TYPES = [];
   }
 });
 
@@ -9155,7 +9158,7 @@ function buildCodeIndex(model) {
   };
   const possibleOriginsOf = (site, from) => {
     const proven = originOf(site, from);
-    if (!site.field && !site.constructed) return proven;
+    if (!site.field && !site.constructed && !site.via) return proven;
     const resolved = scopeOf2(site, from);
     if (!resolved) return proven;
     const { path: scope, facts: f } = resolved;
@@ -9164,10 +9167,10 @@ function buildCodeIndex(model) {
       const landings = specifier !== void 0 ? landingFrom(scope, specifier) : declarationsAt(scope).has(name) ? republishedFrom(scope) : NO_ORIGIN;
       for (const candidate of landings) out.add(candidate);
     };
-    if (site.field) {
-      for (const typeName of fieldTypesOf(f, site.field)) widenThrough(typeName, typeBindingOf(f, typeName));
-    }
+    const widenThroughType = (typeName) => widenThrough(typeName, typeBindingOf(f, typeName));
+    if (site.field) for (const typeName of fieldTypesOf(f, site.field)) widenThroughType(typeName);
     if (site.constructed) widenThrough(site.constructed, importBindingOf(f, site.constructed)?.from);
+    if (site.via) for (const typeName of localTypesOf(f, site.via)) widenThroughType(typeName);
     return out;
   };
   const declarationsAt = (path70) => namesAt(declarations, pathKey(path70), (f) => /* @__PURE__ */ new Set([...f.declaredNames, ...f.exportedNames]));
@@ -13652,7 +13655,7 @@ var init_call_conformance = __esm({
     claimNoun = (implMethod) => implMethod.narrative.length ? "narrative call step(s)" : "declared call(s)";
     callConformanceRule = {
       name: "call-conformance",
-      description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
+      description: "Code\u2194spec Level 3: the CLAIMED call \u2194 realized call relation, judged both ways against the method's own source file (its sourcePath, else the implementation's), at exact analysis grade only. A method claims a call two ways and they face one check: a narrative `call` step, and an entry of the declared `calls` a narrative-less method reaches its collaborators through. They assert the same thing, and the step number is no part of the claim \u2014 this check never reads order, so it is only how a finding points at one. Forward: every claim must be realized by a call whose callee RESOLVES TO one of the target method's own source files \u2014 the target's contract name or a per-method `symbol` override, closed transitively over the named helpers the realized function calls, and resolved against every file the call CAN have reached: a `this.<field>.<method>()` receiver followed through the field's DECLARED TYPE, a `new Class(...).<method>()` receiver through the module its CLASS NAME came from, and a plain `<name>.<method>()` receiver through the type the file ANNOTATES that name with \u2014 a parameter's, or an annotated variable's, which is how a module that wires its collaborators as closures writes every one of its calls. A matching call whose origin a pure model cannot resolve is reported apart as CALL_ORIGIN_UNRESOLVED, which NAMES the shape it could not follow and asks for nothing \u2014 a coverage hole in the reader, reported for the reason CONFORMANCE_DEGRADED is: a silently degraded gate is worse than a degraded one. A finding names a landing only from the PROVEN tier so that widening what a call reached can accept a claim but never accuse one, and a target that names no file of its own falls back to name membership. Converse: a call that resolves to a modelled method of ANOTHER component in the SAME file crosses a component boundary while looking local, so the method must claim it \u2014 in a step or in `calls` (UNDECLARED_COLOCATED_CALL) \u2014 judged on the proven tier alone, and a same-file private helper is no modelled method and is never reported. A method that claims nothing at all is judged in neither direction: what it leaves unsaid is UNUSED_*'s subject. Order, arguments and conditions stay unverified, dispatch steps (runtime-table routed) are no claim about a call site, a malformed declared reference is MALFORMED_DECLARED_CALL's finding and names no target here, the conformance dial (off) skips, and weaker analysis grades never guess.",
       codes: [
         { code: "CALL_STEP_UNREALIZED", defaultSeverity: "warning", summary: "Narrative call step or declared call realized by no call that resolves to the target method's own source file \u2014 the call is absent, or it lands in another module", carryable: true },
         { code: "CALL_ORIGIN_UNRESOLVED", defaultSeverity: "warning", summary: "Narrative call step or declared call whose target name IS called, but only from call sites written in a shape this analysis cannot resolve to a file \u2014 the claim was not checked, and is neither proven realized nor accused", carryable: true },
@@ -13728,7 +13731,7 @@ var init_call_conformance = __esm({
             ctx.addIssue(
               "warning",
               "CALL_ORIGIN_UNRESOLVED",
-              `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does. What does not: an import from a PACKAGE specifier, a receiver holding a value the module assembled, a receiver this model records no name for. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
+              `Method "${implMethod.name}" in implementation "${impl.id}": ${unresolved.length} ${claimNoun(implMethod)} ARE called by name inside the function "${fnSymbol}" in "${file}", but every site calling them is written in a shape this analysis cannot resolve to a file \u2014 ${unresolved.map(describeMiss).join("; ")}. What resolves is a name bound to a module of THIS project: a bare or namespaced call through such an import binding, a \`this.<field>\` receiver whose declared type names one, a \`new Class(\u2026)\` receiver whose class does, and a receiver NAME the file annotates with a type that does. What does not: an import from a PACKAGE specifier, a receiver holding a value the module assembled, a receiver this model records no name for, and one the file annotates with nothing. This reports what was not checked, not what is wrong \u2014 the claim is neither proven realized nor accused of being missing, and no working call is asked to be rewritten to suit the reader.`,
               impl.id,
               entry.draftContext,
               void 0,
@@ -15920,6 +15923,7 @@ function walkExact(ts, sourceText, fileName) {
   const importBindings = /* @__PURE__ */ new Map();
   const typeOnlyBindings = /* @__PURE__ */ new Map();
   const fieldTypes = /* @__PURE__ */ new Map();
+  const localTypes = /* @__PURE__ */ new Map();
   const mutableBindings = /* @__PURE__ */ new Set();
   const receiverKey = (site) => site.via ?? (site.field ? `this.${site.field}` : site.constructed ? `new ${site.constructed}` : "");
   const siteKey = (site) => `${site.member ? "m" : "b"}:${receiverKey(site)}:${site.name}`;
@@ -15947,6 +15951,13 @@ function walkExact(ts, sourceText, fileName) {
     named.add(typeName);
     fieldTypes.set(field, named);
   };
+  const recordLocalType = (name, type) => {
+    const typeName = typeReferenceName(type);
+    if (!typeName || !ts.isIdentifier(name)) return;
+    const named = localTypes.get(name.text) ?? /* @__PURE__ */ new Set();
+    named.add(typeName);
+    localTypes.set(name.text, named);
+  };
   const hasExportModifier = (node) => {
     const mods = node.modifiers;
     return !!mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
@@ -16014,6 +16025,7 @@ function walkExact(ts, sourceText, fileName) {
     else if (ts.isParameter(node) && node.parent && ts.isConstructorDeclaration(node.parent) && isParameterProperty(node)) {
       recordFieldType(node.name, node.type);
     }
+    if (ts.isParameter(node) || ts.isVariableDeclaration(node)) recordLocalType(node.name, node.type);
     if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
       const name = node.name && ts.isIdentifier(node.name) ? node.name.text : void 0;
       if (name) {
@@ -16090,7 +16102,7 @@ function walkExact(ts, sourceText, fileName) {
   };
   visit(sf);
   const reexportOnly = sf.statements.length > 0 && sf.statements.every((st) => ts.isExportDeclaration(st) && !!st.moduleSpecifier);
-  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, importBindings, typeOnlyBindings, fieldTypes, mutableBindings, reexportOnly };
+  return { declared, anchors, exported, imports, reexports, starExports, namedReexports, complexity, calls, importBindings, typeOnlyBindings, fieldTypes, localTypes, mutableBindings, reexportOnly };
 }
 function resolveRelativeModule(fromFile, specifier) {
   if (!specifier.startsWith(".")) return null;
@@ -16271,6 +16283,7 @@ function buildCodeModel(implementations, types, projectRoot2, sourceRoots = [],
             importBindings: Object.fromEntries(facts.importBindings),
             typeOnlyBindings: Object.fromEntries(facts.typeOnlyBindings),
             fieldTypes: Object.fromEntries([...facts.fieldTypes].map(([k, v]) => [k, [...v]])),
+            localTypes: Object.fromEntries([...facts.localTypes].map(([k, v]) => [k, [...v]])),
             topLevelMutableBindings: [...facts.mutableBindings],
             reexportOnly: facts.reexportOnly
           };