@abco20/btxml-checker 0.1.3 → 0.1.5

package/dist/server.cjs

@@ -34993,6 +34993,7 @@ var RuleCodes = {
   ConflictingModelKind: "BT120_CONFLICTING_MODEL_KIND",
   UnusedModelDefinition: "BT121_UNUSED_MODEL_DEFINITION",
   DuplicateModelDefinition: "BT122_DUPLICATE_MODEL_DEFINITION",
+  MissingLocalModelDefinition: "BT123_MISSING_LOCAL_MODEL_DEFINITION",
   ExternalModelFileNotFound: "BT321_EXTERNAL_MODEL_FILE_NOT_FOUND",
   AugmentationFileNotFound: "BT324_AUGMENTATION_FILE_NOT_FOUND",
   MissingTreeNodesModel: "BT322_MISSING_TREENODESMODEL",
@@ -35213,8 +35214,8 @@ var RULES = {
   },
   "model/require-output-port-remap": {
     code: RuleCodes.OutputPortRequiresRemap,
-    defaultSeverity: "warn",
-    description: "Resolved output ports must write to a blackboard remap."
+    defaultSeverity: "error",
+    description: "Resolved output ports must be explicitly or default-remapped to a blackboard entry."
   },
   "model/no-childless-control-shape-mismatch": {
     code: RuleCodes.ChildCapableNodeSelfClosing,
@@ -35246,6 +35247,11 @@ var RULES = {
     defaultSeverity: "error",
     description: "Inline model definitions should be used in the same BT XML file."
   },
+  "model/require-local-definition": {
+    code: RuleCodes.MissingLocalModelDefinition,
+    defaultSeverity: "error",
+    description: "When models.convention is used-only, normal node usages should have a local TreeNodesModel definition in the same file."
+  },
   "model/no-duplicate-definition": {
     code: RuleCodes.DuplicateModelDefinition,
     defaultSeverity: "error",
@@ -39197,6 +39203,8 @@ async function resolveIncludeGraph(input) {
 var RULE_CONFLICTING_KIND = "model/no-conflicting-kind-for-id";
 var RULE_UNUSED_DEFINITION = "model/no-unused-definition";
 var RULE_DUPLICATE_DEFINITION = "model/no-duplicate-definition";
+var RULE_REQUIRE_LOCAL_DEFINITION = "model/require-local-definition";
+var NORMAL_MODEL_KINDS = /* @__PURE__ */ new Set(["Action", "Condition", "Decorator", "Control"]);
 function createConventionDiagnostic(input) {
   const diagnostic = createDiagnostic(
     input.code,
@@ -39223,6 +39231,9 @@ function resolveConventionSeverity(config2, rule) {
 function definitionRange(definition) {
   return definition.model.idRange ?? definition.range;
 }
+function definitionDeleteRange(definition) {
+  return definition.range;
+}
 function definitionInfo(definition) {
   return {
     uri: definition.uri,
@@ -39231,6 +39242,30 @@ function definitionInfo(definition) {
     range: definition.range
   };
 }
+function isNormalModelKind(kind) {
+  return NORMAL_MODEL_KINDS.has(kind);
+}
+function toFixableModel(index, id) {
+  const resolved = getNodeModel(index, id);
+  if (!resolved) return void 0;
+  if (!isNormalModelKind(resolved.kind)) return void 0;
+  const hasConflict = getModelConflicts(index).some(
+    (conflict) => conflict.id === id && (conflict.code === "BT012_CONFLICTING_NODE_MODEL" || conflict.code === "BT107_CONFLICTING_PORT_DEFAULT")
+  );
+  if (hasConflict) return void 0;
+  return {
+    id: resolved.id,
+    kind: resolved.kind,
+    ports: resolved.ports.map((port) => ({
+      direction: port.direction,
+      name: port.name,
+      type: port.type,
+      defaultValue: port.defaultValue,
+      description: port.description,
+      enum: port.enum
+    }))
+  };
+}
 function validateConflictingKinds(input) {
   const severity = resolveConventionSeverity(input.config, RULE_CONFLICTING_KIND);
   if (!severity) return [];
@@ -39274,17 +39309,75 @@ function validateConflictingKinds(input) {
 function validateUsedOnly(input) {
   if (input.config.models.convention !== "used-only") return [];
   const severity = resolveConventionSeverity(input.config, RULE_UNUSED_DEFINITION);
-  if (!severity) return [];
+  const missingSeverity = resolveConventionSeverity(input.config, RULE_REQUIRE_LOCAL_DEFINITION);
+  if (!severity && !missingSeverity) return [];
   const diagnostics = [];
   const usagesByUri = getNodeUsagesByUri(input.index);
-  for (const definition of input.facts) {
-    if (definition.isBuiltin) continue;
+  const allInlineByUri = buildAllInlineDefinitionsByUri(input.facts);
+  const localNormalByUri = buildLocalNormalDefinitionsByUri(input.facts);
+  const relevantUris = /* @__PURE__ */ new Set([
+    ...usagesByUri.keys(),
+    ...localNormalByUri.keys(),
+    ...allInlineByUri.keys()
+  ]);
+  for (const uri of relevantUris) {
+    const sameFileNodeUsages = usagesByUri.get(uri) ?? [];
+    const usedNodeIds = getUsedNodeIds(sameFileNodeUsages);
+    const localNormalDefinitions = localNormalByUri.get(uri) ?? [];
+    const localNormalIds = new Set(localNormalDefinitions.map((definition) => definition.id));
+    const localAnyIds = new Set((allInlineByUri.get(uri) ?? []).map((definition) => definition.id));
+    if (severity) {
+      diagnostics.push(
+        ...createUnusedDefinitionDiagnostics(localNormalDefinitions, usedNodeIds, severity)
+      );
+    }
+    if (missingSeverity) {
+      diagnostics.push(
+        ...createMissingLocalDefinitionDiagnostics({
+          index: input.index,
+          uri,
+          usedNodeIds,
+          localNormalIds,
+          localAnyIds,
+          sameFileNodeUsages,
+          severity: missingSeverity
+        })
+      );
+    }
+  }
+  return diagnostics;
+}
+function buildAllInlineDefinitionsByUri(facts) {
+  const allInlineByUri = /* @__PURE__ */ new Map();
+  for (const definition of facts) {
     if (definition.sourceKind !== "inline-tree-nodes-model") continue;
-    if (definition.kind === "SubTree") continue;
-    const sameFileNodeUsages = usagesByUri.get(definition.uri ?? "") ?? [];
-    const usedNodeIds = new Set(
-      sameFileNodeUsages.filter((usage) => usage.kind === "node").map((usage) => usage.id)
-    );
+    if (!definition.uri) continue;
+    const allInline = allInlineByUri.get(definition.uri) ?? [];
+    allInline.push(definition);
+    allInlineByUri.set(definition.uri, allInline);
+  }
+  return allInlineByUri;
+}
+function buildLocalNormalDefinitionsByUri(facts) {
+  const localNormalByUri = /* @__PURE__ */ new Map();
+  for (const definition of facts) {
+    if (definition.sourceKind !== "inline-tree-nodes-model") continue;
+    if (!definition.uri) continue;
+    if (!isNormalModelKind(definition.kind)) continue;
+    const localNormal = localNormalByUri.get(definition.uri) ?? [];
+    localNormal.push(definition);
+    localNormalByUri.set(definition.uri, localNormal);
+  }
+  return localNormalByUri;
+}
+function getUsedNodeIds(sameFileNodeUsages) {
+  return new Set(
+    sameFileNodeUsages.filter((usage) => usage.kind === "node").map((usage) => usage.id)
+  );
+}
+function createUnusedDefinitionDiagnostics(localNormalDefinitions, usedNodeIds, severity) {
+  const diagnostics = [];
+  for (const definition of localNormalDefinitions) {
     if (usedNodeIds.has(definition.id)) continue;
     diagnostics.push(
       createConventionDiagnostic({
@@ -39299,10 +39392,47 @@ function validateUsedOnly(input) {
           nodeId: definition.id,
           modelKind: definition.kind,
           sourceKind: "inline-tree-nodes-model",
-          fix: definition.uri && definitionRange(definition) && definition.editable ? {
+          fix: definition.uri && definitionDeleteRange(definition) && definition.editable ? {
             kind: "delete-definition",
             uri: definition.uri,
-            range: definitionRange(definition)
+            range: definitionDeleteRange(definition)
+          } : void 0
+        }
+      })
+    );
+  }
+  return diagnostics;
+}
+function createMissingLocalDefinitionDiagnostics(input) {
+  const diagnostics = [];
+  for (const nodeId of input.usedNodeIds) {
+    if (input.localNormalIds.has(nodeId)) continue;
+    const hasNormalModel = getNodeModelDefinitions(input.index, nodeId).some(
+      (definition) => isNormalModelKind(definition.kind)
+    );
+    if (!hasNormalModel) continue;
+    const hasNonNormalLocalDefinition = input.localAnyIds.has(nodeId);
+    const firstUsage = input.sameFileNodeUsages.find(
+      (usage) => usage.kind === "node" && usage.id === nodeId
+    );
+    const fixableModel = hasNonNormalLocalDefinition ? void 0 : toFixableModel(input.index, nodeId);
+    diagnostics.push(
+      createConventionDiagnostic({
+        code: "BT123_MISSING_LOCAL_MODEL_DEFINITION",
+        message: `missing local model definition \`${nodeId}\` in this file`,
+        uri: input.uri,
+        range: firstUsage?.elementRange ?? firstUsage?.range,
+        rule: RULE_REQUIRE_LOCAL_DEFINITION,
+        severity: input.severity,
+        data: {
+          kind: "missing-local-model-definition",
+          nodeId,
+          sourceKind: "inline-tree-nodes-model",
+          fix: fixableModel && input.uri ? {
+            kind: "add-local-definition",
+            uri: input.uri,
+            nodeId,
+            model: fixableModel
           } : void 0
         }
       })
@@ -39317,7 +39447,7 @@ function duplicateFix(definitions) {
   if (!keep?.uri) return void 0;
   const deleteTargets = definitions.filter((definition) => definition !== keep);
   if (deleteTargets.some(
-    (definition) => !definition.uri || !definitionRange(definition) || !definition.editable
+    (definition) => !definition.uri || !definitionDeleteRange(definition) || !definition.editable
   )) {
     return void 0;
   }
@@ -39329,7 +39459,7 @@ function duplicateFix(definitions) {
     },
     delete: deleteTargets.map((definition) => ({
       uri: definition.uri,
-      range: definitionRange(definition)
+      range: definitionDeleteRange(definition)
     }))
   };
 }
@@ -40256,7 +40386,9 @@ var modelRules = [
   }),
   makeRuleModule({
     name: "model/valid-port-name",
-    meta: { description: "Port names must be valid XML attribute names for BT nodes." },
+    meta: {
+      description: "Port names must be valid XML attribute names for BT nodes."
+    },
     create(context) {
       return {
         TreeNodeModel(node) {
@@ -40301,7 +40433,9 @@ var modelRules = [
   }),
   makeRuleModule({
     name: "model/valid-port-default-value",
-    meta: { description: "TreeNodesModel port defaults must match the declared type." },
+    meta: {
+      description: "TreeNodesModel port defaults must match the declared type."
+    },
     create(context) {
       return {
         Element(element) {
@@ -40411,7 +40545,7 @@ var modelRules = [
   makeRuleModule({
     name: "model/require-output-port-remap",
     meta: {
-      description: "Resolved output ports must write to a blackboard remap."
+      description: "Resolved output ports must be explicitly or default-remapped to a blackboard entry."
     },
     create(context) {
       return {
@@ -40419,19 +40553,34 @@ var modelRules = [
           if (isStructuralElement2(element)) return;
           const usage = context.getNodeUsage(element);
           if (usage.model.status !== "resolved" && usage.tagForm !== "subtree") return;
-          for (const attr of element.attributes) {
-            const portUsage = context.getPortUsage(element, attr.name);
-            if (portUsage?.status !== "resolved") continue;
-            if (portUsage.port.direction !== "output") continue;
-            if (getExactBlackboardReference(portUsage.port.name, attr.value) !== void 0)
+          for (const port of usage.ports) {
+            if (port.direction !== "output") continue;
+            const binding = usage.portUsages.find(
+              (candidate) => candidate.name === port.name && candidate.status === "resolved"
+            );
+            if (binding) {
+              if (getExactBlackboardReference(port.name, binding.value) !== void 0) continue;
+              context.report({
+                code: RuleCodes.OutputPortRequiresRemap,
+                message: `output port \`${port.name}\` must be remapped to a blackboard entry`,
+                range: binding.attribute.range,
+                details: {
+                  primaryLabel: `output port \`${port.name}\` requires a blackboard remap`,
+                  help: `use \`${port.name}="{${port.name}}"\` or \`${port.name}="{some_key}"\``
+                }
+              });
+              continue;
+            }
+            if (port.defaultValue !== void 0 && getExactBlackboardReference(port.name, port.defaultValue) !== void 0) {
               continue;
+            }
             context.report({
               code: RuleCodes.OutputPortRequiresRemap,
-              message: `output port \`${portUsage.port.name}\` must be remapped to a blackboard entry`,
-              range: attr.range,
+              message: `output port \`${port.name}\` must be remapped to a blackboard entry`,
+              range: element.range,
               details: {
-                primaryLabel: `output port \`${portUsage.port.name}\` requires a blackboard remap`,
-                help: `use \`${portUsage.port.name}="{${portUsage.port.name}}"\` or \`${portUsage.port.name}="{some_key}"\``
+                primaryLabel: `output port \`${port.name}\` requires a blackboard remap`,
+                help: `use \`${port.name}="{${port.name}}"\` or \`${port.name}="{some_key}"\``
               }
             });
           }
@@ -44002,12 +44151,15 @@ function removeAttributeEdit(document, attribute) {
   return { range, newText: "" };
 }
 function addAttributeEdit(document, element, name) {
+  return addAttributeWithValueEdit(document, element, name, "");
+}
+function addAttributeWithValueEdit(document, element, name, value) {
   const closeOffset = Math.max(
     element.openTagRange.end.offset - (element.selfClosing ? 2 : 1),
     element.openTagRange.start.offset
   );
   const pos = document.positionAt(closeOffset);
-  return { range: sourceRange(pos, pos), newText: ` ${name}=""` };
+  return { range: sourceRange(pos, pos), newText: ` ${name}="${value}"` };
 }
 
 // ../language-service/src/ranges.ts
@@ -44028,84 +44180,160 @@ function getCodeActions(context, input) {
     });
   }
   for (const diag of diagnostics) {
-    if (!diag.range) continue;
+    if (!hasRange(diag)) continue;
     const inspect = inspectXmlCursor({
       document: input.document,
       parsed: context.parsed,
       position: diag.range.start
     });
-    if (diag.code === "BT101_MISSING_REQUIRED_PORT") {
-      const targetOffset = Math.min(diag.range.start.offset + 1, diag.range.end.offset);
-      const target = context.parsed?.root ? findElementAt(context.parsed.root, targetOffset) || ("element" in inspect ? inspect.element : void 0) : "element" in inspect ? inspect.element : void 0;
-      if (!target) continue;
-      const usage = resolveNodeUsage(context.semantic, {
-        element: target,
-        documentRoot: context.parsed?.root,
-        uri: input.document.uri,
-        config: context.config,
-        policy: context.nodeUsagePolicy
-      });
-      const missing = usage.ports.find(
-        (port) => port.required && !usage.portUsages.some(
-          (binding) => binding.status === "resolved" && binding.name === port.name
-        )
-      );
-      if (missing) {
-        actions.push({
-          title: `Add missing port ${missing.name}`,
-          kind: "quickfix",
-          diagnostics: [diag],
-          edits: [addAttributeEdit(input.document, target, missing.name)]
-        });
-      }
-    }
-    if (diag.code === "BT102_UNKNOWN_PORT" && "attribute" in inspect && "element" in inspect && inspect.attribute) {
-      const usage = inspect.element ? resolveNodeUsage(context.semantic, {
-        element: inspect.element,
-        documentRoot: context.parsed?.root,
-        uri: input.document.uri,
-        config: context.config,
-        policy: context.nodeUsagePolicy
-      }) : void 0;
-      const unknown2 = usage?.portUsages.find(
-        (candidate) => candidate.status === "undeclared" && candidate.attribute === inspect.attribute
-      );
-      const edit = unknown2 ? removeAttributeEdit(input.document, inspect.attribute) : void 0;
-      if (edit && unknown2) {
-        actions.push({
-          title: `Remove unknown port ${inspect.attribute.name}`,
-          kind: "quickfix",
-          diagnostics: [diag],
-          edits: [edit]
-        });
-      }
-    }
-    if (diag.code === "BT002_MISSING_BTCPP_FORMAT" && context.parsed?.root) {
-      const insertPos = input.document.positionAt(
-        context.parsed.root.nameRange?.end.offset || context.parsed.root.openTagRange.end.offset - 1
-      );
+    const target = resolveTargetElement(context, input, diag, inspect);
+    addMissingRequiredPortAction(actions, context, input, diag.code, diag, target);
+    addOutputRemapAction(actions, context, input, diag.code, diag, inspect, target);
+    addUnknownPortAction(actions, context, input, diag.code, diag, inspect);
+    addMissingBtcppFormatAction(actions, context, input, diag.code, diag);
+    addSuppressionAction(actions, input, diag);
+  }
+  return { actions };
+}
+function hasRange(diag) {
+  return !!diag.range;
+}
+function isResolvedPortUsage(binding) {
+  return binding.status === "resolved";
+}
+function resolveUsage(context, input, element) {
+  return resolveNodeUsage(context.semantic, {
+    element,
+    documentRoot: context.parsed?.root,
+    uri: input.document.uri,
+    config: context.config,
+    policy: context.nodeUsagePolicy
+  });
+}
+function inspectElement(inspect) {
+  return "element" in inspect ? inspect.element : void 0;
+}
+function resolveTargetElement(context, input, diag, inspect) {
+  const fallback = inspectElement(inspect);
+  const root = context.parsed?.root;
+  if (!root || !diag.range) return fallback;
+  const targetOffset = Math.min(diag.range.start.offset + 1, diag.range.end.offset);
+  return findElementAt(root, targetOffset) ?? fallback;
+}
+function addMissingRequiredPortAction(actions, context, input, code, diag, target) {
+  if (code !== "BT101_MISSING_REQUIRED_PORT") return;
+  if (!target) return;
+  const usage = resolveUsage(context, input, target);
+  const missing = usage.ports.find(
+    (port) => port.required && !usage.portUsages.some(
+      (binding) => binding.status === "resolved" && binding.name === port.name
+    )
+  );
+  if (!missing) return;
+  actions.push({
+    title: `Add missing port ${missing.name}`,
+    kind: "quickfix",
+    diagnostics: [diag],
+    edits: [addAttributeEdit(input.document, target, missing.name)]
+  });
+}
+function addOutputRemapAction(actions, context, input, code, diag, inspect, target) {
+  if (code !== "BT115_OUTPUT_PORT_REQUIRES_REMAP") return;
+  if (!target) return;
+  const outputPortName = /`([^`]+)`/.exec(diag.message)?.[1];
+  const usage = resolveUsage(context, input, target);
+  const attribute = "attribute" in inspect ? inspect.attribute : void 0;
+  if (attribute) {
+    const binding = usage.portUsages.find(
+      (candidate) => isResolvedPortUsage(candidate) && candidate.port.direction === "output" && candidate.attribute === attribute && (!outputPortName || candidate.port.name === outputPortName)
+    );
+    if (binding) {
       actions.push({
-        title: 'Add BTCPP_format="4" to <root>',
+        title: `Remap output port ${binding.port.name}`,
         kind: "quickfix",
         diagnostics: [diag],
-        edits: [{ range: sourceRange(insertPos, insertPos), newText: ' BTCPP_format="4"' }]
+        edits: [
+          {
+            range: attribute.valueContentRange ?? attribute.valueRange,
+            newText: `{${binding.port.name}}`
+          }
+        ]
       });
+      return;
     }
-    actions.push({
-      title: `Suppress ${diag.code} for next line`,
-      kind: "quickfix",
-      diagnostics: [diag],
-      edits: [
-        insertAtLineStart(
-          input.document,
-          diag.range.start.line,
-          `<!-- btxml-disable-next-line ${diag.code} reason: TODO -->
-`
-        )
-      ]
-    });
   }
-  return { actions };
+  const missingOutputPort = usage.ports.find(
+    (port) => port.direction === "output" && (!outputPortName || port.name === outputPortName) && !usage.portUsages.some(
+      (binding) => binding.status === "resolved" && binding.name === port.name
+    )
+  );
+  if (!missingOutputPort) return;
+  actions.push({
+    title: `Remap output port ${missingOutputPort.name}`,
+    kind: "quickfix",
+    diagnostics: [diag],
+    edits: [
+      addAttributeWithValueEdit(
+        input.document,
+        target,
+        missingOutputPort.name,
+        `{${missingOutputPort.name}}`
+      )
+    ]
+  });
+}
+function addUnknownPortAction(actions, context, input, code, diag, inspect) {
+  if (code !== "BT102_UNKNOWN_PORT") return;
+  if (!("attribute" in inspect && inspect.attribute)) return;
+  const element = inspectElement(inspect);
+  if (!element) return;
+  const usage = resolveUsage(context, input, element);
+  const unknown2 = usage.portUsages.find(
+    (candidate) => candidate.status === "undeclared" && candidate.attribute === inspect.attribute
+  );
+  if (!unknown2) return;
+  const edit = removeAttributeEdit(input.document, inspect.attribute);
+  if (!edit) return;
+  actions.push({
+    title: `Remove unknown port ${inspect.attribute.name}`,
+    kind: "quickfix",
+    diagnostics: [diag],
+    edits: [edit]
+  });
+}
+function addMissingBtcppFormatAction(actions, context, input, code, diag) {
+  if (code !== "BT002_MISSING_BTCPP_FORMAT") return;
+  if (!context.parsed?.root) return;
+  const insertPos = input.document.positionAt(
+    context.parsed.root.nameRange?.end.offset || context.parsed.root.openTagRange.end.offset - 1
+  );
+  actions.push({
+    title: 'Add BTCPP_format="4" to <root>',
+    kind: "quickfix",
+    diagnostics: [diag],
+    edits: [
+      {
+        range: sourceRange(insertPos, insertPos),
+        newText: ' BTCPP_format="4"'
+      }
+    ]
+  });
+}
+function addSuppressionAction(actions, input, diag) {
+  if (!diag.range) return;
+  actions.push({
+    title: `Suppress ${diag.code} for next line`,
+    kind: "quickfix",
+    diagnostics: [diag],
+    edits: [
+      insertAtLineStart(
+        input.document,
+        diag.range.start.line,
+        `<!-- btxml-disable-next-line ${diag.code} reason: TODO -->
+`
+      )
+    ]
+  });
 }
 
 // ../language-service/src/completions.ts
@@ -46852,7 +47080,7 @@ function handleGetChildCapability(workspace, params) {
 }
 
 // src/server.ts
-var SERVER_VERSION = true ? "0.1.3" : "unknown";
+var SERVER_VERSION = true ? "0.1.5" : "unknown";
 var connection = (0, import_node4.createConnection)(import_node4.ProposedFeatures.all);
 var documents = new import_node4.TextDocuments(TextDocument);
 var openUris = /* @__PURE__ */ new Set();