@abco20/btxml-checker 0.1.2 → 0.1.3

package/dist/server.cjs

@@ -15932,7 +15932,8 @@ var DEFAULT_RESOLVED_BTXML_CONFIG = {
     files: [],
     augmentations: [],
     definitions: [],
-    inline: {}
+    inline: {},
+    convention: "allow-unused"
   },
   linter: {
     enabled: true,
@@ -16425,6 +16426,16 @@ function stripSubTreeReferenceAst(def) {
     parentBehaviorTreeId: def.parentBehaviorTreeId
   };
 }
+function stripNodeUsageAst(def) {
+  return {
+    id: def.id,
+    uri: def.uri,
+    kind: def.kind,
+    range: def.range,
+    elementRange: def.elementRange,
+    parentBehaviorTreeId: def.parentBehaviorTreeId
+  };
+}
 function stripBlackboardReferenceAst(def) {
   return {
     raw: def.raw,
@@ -16445,12 +16456,56 @@ function toPublicDocumentModel(input) {
     kind: input.kind,
     behaviorTrees: input.behaviorTrees.map(stripBehaviorTreeAst),
     subtreeReferences: input.subtreeReferences.map(stripSubTreeReferenceAst),
+    nodeUsages: input.nodeUsages.map(stripNodeUsageAst),
     blackboardReferences: input.blackboardReferences.map(stripBlackboardReferenceAst),
     treeNodesModel: input.treeNodesModel.map(stripTreeNodeModelAst),
     genericSubTreePorts: input.genericSubTreePorts.map(stripPortAst),
     rootMainTreeToExecute: cloneAttributeValueRef(input.rootMainTreeToExecute)
   };
 }
+function extractNodeUsages(root, uri) {
+  if (root.name === "TreeNodesModel") return [];
+  const usages = [];
+  const walk2 = (node, parentBehaviorTreeId, inTreeNodesModel = false) => {
+    if (inTreeNodesModel) return;
+    const nextInTreeNodesModel = node.name === "TreeNodesModel";
+    const currentBehaviorTreeId = node.name === "BehaviorTree" ? getAttr(node, "ID")?.value ?? parentBehaviorTreeId : parentBehaviorTreeId;
+    const isInsideBehaviorTree = currentBehaviorTreeId !== void 0;
+    if (node.name === "SubTree") {
+      const idAttr = getAttr(node, "ID");
+      if (idAttr && isInsideBehaviorTree) {
+        usages.push({
+          id: idAttr.value,
+          kind: "SubTree",
+          uri,
+          range: node.range,
+          elementRange: node.range,
+          parentBehaviorTreeId: currentBehaviorTreeId
+        });
+      }
+    } else if (isInsideBehaviorTree && node.name !== "root" && node.name !== "BehaviorTree" && node.name !== "TreeNodesModel") {
+      usages.push({
+        id: node.name,
+        kind: "node",
+        uri,
+        range: node.range,
+        elementRange: node.range,
+        parentBehaviorTreeId: currentBehaviorTreeId
+      });
+    }
+    for (const child of node.children || []) {
+      if (child.kind === "element") {
+        walk2(child, currentBehaviorTreeId, nextInTreeNodesModel);
+      }
+    }
+  };
+  for (const child of root.children || []) {
+    if (child.kind === "element") {
+      walk2(child);
+    }
+  }
+  return usages;
+}
 function addTreeNodeModelToCollections(input) {
   if (input.node.kind === "SubTree" && input.node.id === "SubTree") {
     input.genericSubTreePorts.push(...input.node.ports);
@@ -16502,6 +16557,7 @@ function extractDocumentModel(document, options) {
     }
   }
   const subtreeReferences = root ? extractSubTreeReferences(root, uri) : [];
+  const nodeUsages = root ? extractNodeUsages(root, uri) : [];
   const blackboardReferences = root ? (() => {
     const refs = [];
     collectBlackboardReferences(root, refs, uri, document.originalText);
@@ -16515,6 +16571,7 @@ function extractDocumentModel(document, options) {
     kind,
     behaviorTrees,
     subtreeReferences,
+    nodeUsages,
     blackboardReferences,
     treeNodesModel,
     genericSubTreePorts,
@@ -34589,12 +34646,14 @@ var resolverConfigSchema = external_exports.object({
   includes: resolverIncludesConfigSchema.optional(),
   behaviorTreeIds: external_exports.enum(["workspace-unique", "file-local-first", "allow-ambiguous"]).optional()
 }).strict();
+var modelConventionSchema = external_exports.enum(["allow-unused", "used-only", "single-source"]);
 var modelsConfigSchema = external_exports.object({
   builtins: external_exports.array(external_exports.enum(SUPPORTED_BUILTIN_MODEL_SETS)).optional(),
   files: external_exports.array(external_exports.string()).optional(),
   augmentations: external_exports.array(external_exports.string()).optional(),
   definitions: external_exports.array(external_exports.string()).optional(),
-  inline: external_exports.record(external_exports.string(), configNodeModelSchema).optional()
+  inline: external_exports.record(external_exports.string(), configNodeModelSchema).optional(),
+  convention: modelConventionSchema.optional()
 }).strict();
 var linterSuppressionsConfigSchema = external_exports.object({
   inline: external_exports.enum(["allow", "deny"]).optional()
@@ -34931,6 +34990,9 @@ var RuleCodes = {
   AugmentTargetNotFound: "BT117_AUGMENT_TARGET_NOT_FOUND",
   AugmentPortNotFound: "BT118_AUGMENT_PORT_NOT_FOUND",
   InvalidTypeRefinement: "BT119_INVALID_TYPE_REFINEMENT",
+  ConflictingModelKind: "BT120_CONFLICTING_MODEL_KIND",
+  UnusedModelDefinition: "BT121_UNUSED_MODEL_DEFINITION",
+  DuplicateModelDefinition: "BT122_DUPLICATE_MODEL_DEFINITION",
   ExternalModelFileNotFound: "BT321_EXTERNAL_MODEL_FILE_NOT_FOUND",
   AugmentationFileNotFound: "BT324_AUGMENTATION_FILE_NOT_FOUND",
   MissingTreeNodesModel: "BT322_MISSING_TREENODESMODEL",
@@ -35174,6 +35236,21 @@ var RULES = {
     defaultSeverity: "error",
     description: "Node model definitions must agree on kind and port shape."
   },
+  "model/no-conflicting-kind-for-id": {
+    code: RuleCodes.ConflictingModelKind,
+    defaultSeverity: "error",
+    description: "A model ID must not be defined with different kinds."
+  },
+  "model/no-unused-definition": {
+    code: RuleCodes.UnusedModelDefinition,
+    defaultSeverity: "error",
+    description: "Inline model definitions should be used in the same BT XML file."
+  },
+  "model/no-duplicate-definition": {
+    code: RuleCodes.DuplicateModelDefinition,
+    defaultSeverity: "error",
+    description: "A user-defined model (ID, kind) should be defined only once."
+  },
   "suppression/no-unused": {
     code: RuleCodes.UnusedSuppression,
     defaultSeverity: "warn",
@@ -36003,6 +36080,18 @@ function getSubTreeReferences(index, id) {
     (model) => model.subtreeReferences.filter((reference) => reference.id === id)
   );
 }
+function getAllNodeUsages(index) {
+  return getAllDocumentModels(index).flatMap((model) => model.nodeUsages);
+}
+function getNodeUsagesByUri(index) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const usage of getAllNodeUsages(index)) {
+    const list = grouped.get(usage.uri) ?? [];
+    list.push(usage);
+    grouped.set(usage.uri, list);
+  }
+  return grouped;
+}
 function getBehaviorTreeIds(index) {
   return [...asSemanticIndexState2(index).behaviorTreesById.keys()];
 }
@@ -36793,6 +36882,50 @@ function findSemanticPortBindingAtPosition(view, position) {
   return void 0;
 }
 
+// ../semantic/src/model-definition-facts.ts
+function modelDefinitionKeyString(key) {
+  return `${key.kind}\0${key.id}`;
+}
+function getModelDefinitionFacts(index) {
+  return getAllNodeModelDefinitions(index).map((model) => {
+    const sourceKind = model.source ?? model.sourceMeta?.sourceKind;
+    return {
+      key: {
+        id: model.id,
+        kind: model.kind
+      },
+      model,
+      id: model.id,
+      kind: model.kind,
+      uri: model.uri,
+      range: model.range,
+      sourceKind,
+      isBuiltin: sourceKind === "builtin",
+      isCanonicalModelFile: sourceKind === "external-tree-nodes-model",
+      editable: model.editable !== false
+    };
+  });
+}
+function groupModelDefinitionsById(facts) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    const list = grouped.get(fact.id) ?? [];
+    list.push(fact);
+    grouped.set(fact.id, list);
+  }
+  return grouped;
+}
+function groupModelDefinitionsByKey(facts) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    const key = modelDefinitionKeyString(fact.key);
+    const list = grouped.get(key) ?? [];
+    list.push(fact);
+    grouped.set(key, list);
+  }
+  return grouped;
+}
+
 // ../syntax/src/parse/document-kind.ts
 function finalizeDocumentKind(input) {
   const { document, diagnostics, options, partial: partial2 } = input;
@@ -39060,6 +39193,192 @@ async function resolveIncludeGraph(input) {
   };
 }
 
+// ../project/src/model-conventions.ts
+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";
+function createConventionDiagnostic(input) {
+  const diagnostic = createDiagnostic(
+    input.code,
+    input.severity,
+    input.message,
+    input.range,
+    input.uri,
+    void 0,
+    input.data
+  );
+  return {
+    ...diagnostic,
+    rule: input.rule,
+    ...input.relatedInformation ? { relatedInformation: input.relatedInformation } : {}
+  };
+}
+function resolveConventionSeverity(config2, rule) {
+  const severity = getRuleSeverity(config2.linter.rules, rule);
+  if (severity === "off") return void 0;
+  if (severity === "info") return DiagnosticSeverity.Info;
+  if (severity === "warn") return DiagnosticSeverity.Warning;
+  return DiagnosticSeverity.Error;
+}
+function definitionRange(definition) {
+  return definition.model.idRange ?? definition.range;
+}
+function definitionInfo(definition) {
+  return {
+    uri: definition.uri,
+    sourceKind: definition.sourceKind,
+    modelKind: definition.kind,
+    range: definition.range
+  };
+}
+function validateConflictingKinds(input) {
+  const severity = resolveConventionSeverity(input.config, RULE_CONFLICTING_KIND);
+  if (!severity) return [];
+  const diagnostics = [];
+  const groupedById = groupModelDefinitionsById(input.facts.filter((fact) => !fact.isBuiltin));
+  for (const [id, definitions] of groupedById) {
+    const kinds = new Set(definitions.map((definition) => definition.kind));
+    if (kinds.size <= 1) continue;
+    const primary = definitions[0];
+    if (!primary) continue;
+    for (const definition of definitions.slice(1)) {
+      if (definition.kind === primary.kind) continue;
+      const primaryRange = definitionRange(primary);
+      const relatedInformation = primary.uri && primaryRange ? [
+        {
+          uri: primary.uri,
+          range: primaryRange,
+          message: "first conflicting definition"
+        }
+      ] : void 0;
+      diagnostics.push(
+        createConventionDiagnostic({
+          code: "BT120_CONFLICTING_MODEL_KIND",
+          message: `model ID \`${id}\` has conflicting kinds (\`${primary.kind}\` vs \`${definition.kind}\`)`,
+          uri: definition.uri,
+          range: definitionRange(definition),
+          rule: RULE_CONFLICTING_KIND,
+          severity,
+          data: {
+            kind: "conflicting-model-kind",
+            nodeId: id,
+            definitions: definitions.map(definitionInfo)
+          },
+          relatedInformation
+        })
+      );
+    }
+  }
+  return diagnostics;
+}
+function validateUsedOnly(input) {
+  if (input.config.models.convention !== "used-only") return [];
+  const severity = resolveConventionSeverity(input.config, RULE_UNUSED_DEFINITION);
+  if (!severity) return [];
+  const diagnostics = [];
+  const usagesByUri = getNodeUsagesByUri(input.index);
+  for (const definition of input.facts) {
+    if (definition.isBuiltin) continue;
+    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 (usedNodeIds.has(definition.id)) continue;
+    diagnostics.push(
+      createConventionDiagnostic({
+        code: "BT121_UNUSED_MODEL_DEFINITION",
+        message: `unused inline model definition \`${definition.id}\` in this file`,
+        uri: definition.uri,
+        range: definitionRange(definition),
+        rule: RULE_UNUSED_DEFINITION,
+        severity,
+        data: {
+          kind: "unused-model-definition",
+          nodeId: definition.id,
+          modelKind: definition.kind,
+          sourceKind: "inline-tree-nodes-model",
+          fix: definition.uri && definitionRange(definition) && definition.editable ? {
+            kind: "delete-definition",
+            uri: definition.uri,
+            range: definitionRange(definition)
+          } : void 0
+        }
+      })
+    );
+  }
+  return diagnostics;
+}
+function duplicateFix(definitions) {
+  const canonical = definitions.filter((definition) => definition.isCanonicalModelFile);
+  if (canonical.length !== 1) return void 0;
+  const keep = canonical[0];
+  if (!keep?.uri) return void 0;
+  const deleteTargets = definitions.filter((definition) => definition !== keep);
+  if (deleteTargets.some(
+    (definition) => !definition.uri || !definitionRange(definition) || !definition.editable
+  )) {
+    return void 0;
+  }
+  return {
+    kind: "delete-non-canonical-definitions",
+    keep: {
+      uri: keep.uri,
+      range: definitionRange(keep)
+    },
+    delete: deleteTargets.map((definition) => ({
+      uri: definition.uri,
+      range: definitionRange(definition)
+    }))
+  };
+}
+function validateSingleSource(input) {
+  if (input.config.models.convention !== "single-source") return [];
+  const severity = resolveConventionSeverity(input.config, RULE_DUPLICATE_DEFINITION);
+  if (!severity) return [];
+  const diagnostics = [];
+  const groupedByKey = groupModelDefinitionsByKey(input.facts.filter((fact) => !fact.isBuiltin));
+  for (const definitions of groupedByKey.values()) {
+    if (definitions.length <= 1) continue;
+    const primary = definitions[0];
+    if (!primary) continue;
+    diagnostics.push(
+      createConventionDiagnostic({
+        code: "BT122_DUPLICATE_MODEL_DEFINITION",
+        message: `duplicate model definition for \`${primary.id}\` (${primary.kind})`,
+        uri: primary.uri,
+        range: definitionRange(primary),
+        rule: RULE_DUPLICATE_DEFINITION,
+        severity,
+        data: {
+          kind: "duplicate-model-definition",
+          nodeId: primary.id,
+          modelKind: primary.kind,
+          definitions: definitions.map((definition) => ({
+            uri: definition.uri,
+            sourceKind: definition.sourceKind,
+            range: definition.range,
+            canonical: definition.isCanonicalModelFile,
+            editable: definition.editable
+          })),
+          fix: duplicateFix(definitions)
+        }
+      })
+    );
+  }
+  return diagnostics;
+}
+function validateModelConventions(input) {
+  if (input.config.linter.enabled === false) return [];
+  const facts = getModelDefinitionFacts(input.index);
+  return [
+    ...validateConflictingKinds({ config: input.config, facts }),
+    ...validateUsedOnly({ config: input.config, index: input.index, facts }),
+    ...validateSingleSource({ config: input.config, facts })
+  ];
+}
+
 // ../project/src/node-definitions.ts
 function createPositionAt2(text) {
   const lineStarts = [0];
@@ -39257,7 +39576,10 @@ async function buildProjectIndex(input) {
   }) : void 0;
   const externalDocs = input.externalModelDocuments;
   const augmentations = input.augmentations;
-  const nodeDefinitions = await loadProjectNodeModels({ project: input.project, host: input.host });
+  const nodeDefinitions = await loadProjectNodeModels({
+    project: input.project,
+    host: input.host
+  });
   diagnostics.push(...nodeDefinitions.diagnostics);
   const nodeDefinitionModels = nodeDefinitions.nodeModels;
   const activeDocs = graphResult && (mode === "entrypoints" || input.resolveGraph) ? uniqueDocuments([
@@ -39279,7 +39601,13 @@ async function buildProjectIndex(input) {
     includeIssuesByUri: groupIncludeIssues(graphResult?.issues ?? []),
     suppressionIssuesByUri: /* @__PURE__ */ new Map()
   };
-  diagnostics.push(...semanticResult.diagnostics);
+  diagnostics.push(
+    ...semanticResult.diagnostics,
+    ...validateModelConventions({
+      config: resolvedConfig,
+      index: semanticResult.index
+    })
+  );
   const reachableBehaviorTreesById = new Map(
     getBehaviorTreeIds(semanticResult.index).map((id) => [
       id,
@@ -46524,7 +46852,7 @@ function handleGetChildCapability(workspace, params) {
 }
 
 // src/server.ts
-var SERVER_VERSION = true ? "0.1.2" : "unknown";
+var SERVER_VERSION = true ? "0.1.3" : "unknown";
 var connection = (0, import_node4.createConnection)(import_node4.ProposedFeatures.all);
 var documents = new import_node4.TextDocuments(TextDocument);
 var openUris = /* @__PURE__ */ new Set();