@documentation-robotics/cli 0.3.0 → 0.4.0

package/dist/mcp/tools/model-add.js

@@ -1,102 +1,218 @@
 import { z } from "zod";
+import { strictItem } from "../strict-schema.js";
+import { ChangesetGraph } from "../../core/changeset-graph.js";
 import { Element } from "../../core/element.js";
 import { Layer } from "../../core/layer.js";
 import { MutationHandler } from "../../core/mutation-handler.js";
+import { countByStatus, planRelationshipBatch } from "../../core/relationship-staging.js";
+import { StagingAreaManager } from "../../core/staging-area.js";
 import { getAllLayerIds, isValidLayer } from "../../generated/layer-registry.js";
 import { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from "../../generated/node-types.js";
 import { generateElementId, generateUUID } from "../../utils/id-generator.js";
-import { buildSourceReference, validateSourceReferenceOptions } from "../../utils/source-reference.js";
+import { buildSourceReference, resolveSourceReferenceOptions } from "../../utils/source-reference.js";
 import { schemaLookupHint } from "../../utils/error-hints.js";
 import { SchemaValidator } from "../../validators/schema-validator.js";
-import { CLIError, ErrorCategory, findSimilar, formatValidOptions } from "../../utils/errors.js";
+import { CLIError, ErrorCategory, findSimilar, formatValidOptions, getErrorMessage } from "../../utils/errors.js";
 import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
-const inputSchema = {
-  layer: z.string().describe("Canonical layer name (e.g. 'api', 'data-model')."),
-  type: z.string().describe("Element type within the layer (e.g. 'operation', 'entity')."),
-  name: z.string().describe("Human-readable element name; used to derive the element ID."),
+import { activeStagedChangeset } from "./changeset-shared.js";
+import { applyRelationshipPlan, previewChangeset, relationshipItemSchema } from "./relationship-tools.js";
+const provenanceSchema = z.enum(["extracted", "manual", "inferred", "generated"]).optional().describe("How the source reference was made. Defaults to 'manual' when sourceFile is sent alone. 'extracted' and 'manual' need a sourceFile (sent without one, it is ignored with a warning). For a planned element with no code yet, send no source fields."), elementFields = {
   description: z.string().optional(),
   attributes: z.record(z.string(), z.unknown()).optional().describe("Type-specific attributes, validated against the element's spec schema."),
   sourceFile: z.string().optional().describe("Source file path relative to the repository root."),
   sourceSymbol: z.string().optional(),
-  sourceProvenance: z.enum(["extracted", "manual", "inferred", "generated"]).optional(),
+  sourceProvenance: provenanceSchema,
   sourceRepoRemote: z.string().optional(),
-  sourceRepoCommit: z.string().optional().describe("Full 40-character Git commit SHA."),
+  sourceRepoCommit: z.string().optional().describe("Full 40-character Git commit SHA.")
+}, elementItemSchema = strictItem("An elements[] item", {
+  layer: z.string().describe("Canonical layer name."),
+  type: z.string().describe("Element type within the layer."),
+  name: z.string().describe("Human-readable element name; used to derive the element ID."),
+  ...elementFields
+}), inputSchema = {
+  layer: z.string().optional().describe("Canonical layer name (e.g. 'api', 'data-model'). Single form."),
+  type: z.string().optional().describe("Element type within the layer (e.g. 'operation', 'entity'). Single form."),
+  name: z.string().optional().describe("Human-readable element name; used to derive the element ID. Single form."),
+  ...elementFields,
+  elements: z.array(elementItemSchema).optional().describe("Batch form, instead of layer/type/name: a list of elements ({layer, type, name, description?, attributes?, source fields?}), staged in one write. Each is validated on its own; an invalid one is skipped and reported."),
+  relationships: z.array(relationshipItemSchema).optional().describe("Batch form only: relationships to stage in the same write, as relationship_add takes them. They may name elements this call adds (by the id layer.type.kebab-name)."),
   rootPath: rootPathSchema
-};
+}, SINGLE_FORM_FIELDS = [
+  "layer",
+  "type",
+  "name",
+  ...Object.keys(elementFields)
+];
+async function prepareElement(spec) {
+  if (!isValidLayer(spec.layer)) {
+    const validLayers = getAllLayerIds(), similar = findSimilar(spec.layer, validLayers, 3), suggestions = [`Use a valid layer name: ${formatValidOptions(validLayers)}`];
+    throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Unknown layer "${spec.layer}"`, ErrorCategory.USER, suggestions);
+  }
+  if (!isValidNodeType(spec.layer, spec.type)) {
+    const typeNames = getNodeTypesForLayer(spec.layer).map((t) => t.type).sort(), similar = findSimilar(spec.type, typeNames, 3), suggestions = [`Valid types for ${spec.layer}: ${formatValidOptions(typeNames)}`];
+    throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Invalid element type "${spec.type}" for layer "${spec.layer}"`, ErrorCategory.USER, suggestions);
+  }
+  const resolvedType = normalizeNodeType(spec.layer, spec.type), elementPath = generateElementId(spec.layer, resolvedType, spec.name);
+  if (!elementPath.split(".")[2])
+    throw new CLIError(`Cannot generate a valid element ID from name "${spec.name}"`, ErrorCategory.USER, [
+      "Element names must contain at least one letter or digit"
+    ]);
+  const { options: sourceOptions, warnings } = resolveSourceReferenceOptions(spec, "mcp"), now = (/* @__PURE__ */ new Date()).toISOString(), element = new Element({
+    id: generateUUID(),
+    path: elementPath,
+    spec_node_id: `${spec.layer}.${resolvedType}`,
+    layer_id: spec.layer,
+    type: resolvedType,
+    name: spec.name,
+    description: spec.description,
+    attributes: spec.attributes ?? {},
+    metadata: {
+      created_at: now,
+      updated_at: now,
+      version: 1
+    },
+    layer: spec.layer
+  }), sourceRef = buildSourceReference(sourceOptions);
+  sourceRef && element.setSourceReference(sourceRef);
+  const schemaValidator = new SchemaValidator(), tempLayer = new Layer(spec.layer);
+  tempLayer.addElement(element);
+  const attrValidation = await schemaValidator.validateLayer(tempLayer);
+  if (!attrValidation.isValid()) {
+    const errorMessages = attrValidation.errors.map((e) => `  ${e.message}`).join(`
+`);
+    throw new CLIError(`Element ${elementPath} has invalid attributes:
+${errorMessages}`, ErrorCategory.USER, [
+      schemaLookupHint("mcp", spec.layer, resolvedType)
+    ]);
+  }
+  return { element, id: elementPath, layer: spec.layer, type: resolvedType, warnings };
+}
 async function modelAddHandler(args) {
   return runTool(async () => {
-    if (!isValidLayer(args.layer)) {
-      const validLayers = getAllLayerIds(), similar = findSimilar(args.layer, validLayers, 3), suggestions = [`Use a valid layer name: ${formatValidOptions(validLayers)}`];
-      throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Unknown layer "${args.layer}"`, ErrorCategory.USER, suggestions);
+    if (args.elements !== void 0) {
+      const singleFields = SINGLE_FORM_FIELDS.filter((field) => args[field] !== void 0);
+      if (singleFields.length > 0)
+        throw new CLIError(`Send either a single element or elements, not both (got ${singleFields.join(", ")} beside elements)`, ErrorCategory.USER, ["Put those fields on the items of the elements list"]);
+      return jsonResult(await addElementBatch(args.elements, args.relationships ?? [], args.rootPath));
     }
-    if (!isValidNodeType(args.layer, args.type)) {
-      const typeNames = getNodeTypesForLayer(args.layer).map((t) => t.type).sort(), similar = findSimilar(args.type, typeNames, 3), suggestions = [`Valid types for ${args.layer}: ${formatValidOptions(typeNames)}`];
-      throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Invalid element type "${args.type}" for layer "${args.layer}"`, ErrorCategory.USER, suggestions);
-    }
-    const resolvedType = normalizeNodeType(args.layer, args.type), elementPath = generateElementId(args.layer, resolvedType, args.name), elementUUID = generateUUID();
-    if (!elementPath.split(".")[2])
-      throw new CLIError(`Cannot generate a valid element ID from name "${args.name}"`, ErrorCategory.USER, [
-        "Element names must contain at least one letter or digit"
+    if (args.relationships !== void 0)
+      throw new CLIError("relationships goes with the elements list", ErrorCategory.USER, [
+        "Send {elements: [...], relationships: [...]}, or use relationship_add for relationships alone"
       ]);
-    validateSourceReferenceOptions(args, "mcp");
-    const model = await loadModel(args.rootPath), layerKnown = model.getLayerNames().includes(args.layer);
-    let layerObj = await model.getLayer(args.layer), isNewLayer = !1;
-    layerObj || (layerObj = new Layer(args.layer), isNewLayer = !0);
-    const now = (/* @__PURE__ */ new Date()).toISOString(), element = new Element({
-      id: elementUUID,
-      path: elementPath,
-      spec_node_id: `${args.layer}.${resolvedType}`,
-      layer_id: args.layer,
-      type: resolvedType,
-      name: args.name,
-      description: args.description,
-      attributes: args.attributes ?? {},
-      metadata: {
-        created_at: now,
-        updated_at: now,
-        version: 1
-      },
-      layer: args.layer
-    }), sourceRef = buildSourceReference(args);
-    sourceRef && element.setSourceReference(sourceRef);
-    {
-      const schemaValidator = new SchemaValidator(), tempLayer = new Layer(args.layer);
-      tempLayer.addElement(element);
-      const attrValidation = await schemaValidator.validateLayer(tempLayer);
-      if (!attrValidation.isValid()) {
-        const errorMessages = attrValidation.errors.map((e) => `  ${e.message}`).join(`
-`);
-        throw new CLIError(`Element ${elementPath} has invalid attributes:
-${errorMessages}`, ErrorCategory.USER, [
-          schemaLookupHint("mcp", args.layer, resolvedType)
-        ]);
-      }
-    }
-    if (layerObj.getElement(elementPath))
-      throw new CLIError(`Element ${elementPath} already exists in ${args.layer} layer`, ErrorCategory.USER, [
-        'Use "model_show" to view the existing element',
-        'Use "model_update" to modify it',
-        'Use "model_delete" to remove it first if you want to recreate it'
+    if (!args.layer || !args.type || !args.name)
+      throw new CLIError("model_add needs layer, type and name, or an elements list", ErrorCategory.USER, [
+        'Single: {layer: "api", type: "operation", name: "Create Order"}',
+        "Batch: {elements: [{layer, type, name}, ...], relationships: [{source, predicate, target}, ...]}"
       ]);
-    isNewLayer && model.addLayer(layerObj);
-    const mutationHandler = new MutationHandler(model, elementPath, args.layer);
-    await mutationHandler.executeAdd(element, (elem) => {
-      layerObj.addElement(elem);
-    });
-    const activeChangeset = await mutationHandler.getStagingManager().getActive(), staged = !!(activeChangeset && activeChangeset.status === "staged");
-    return staged && !layerKnown && await reloadModel(args.rootPath), jsonResult({
-      status: staged ? "staged" : "added",
-      changeset: staged ? activeChangeset.name : void 0,
-      id: elementPath,
-      layer: args.layer,
-      type: resolvedType,
-      name: args.name
+    return addSingleElement({ ...args, layer: args.layer, type: args.type, name: args.name }, args.rootPath);
+  });
+}
+async function addSingleElement(spec, rootPath) {
+  const prepared = await prepareElement(spec), { element, id: elementPath, layer } = prepared, model = await loadModel(rootPath), layerKnown = model.getLayerNames().includes(layer);
+  let layerObj = await model.getLayer(layer), isNewLayer = !1;
+  if (layerObj || (layerObj = new Layer(layer), isNewLayer = !0), layerObj.getElement(elementPath))
+    throw new CLIError(`Element ${elementPath} already exists in ${layer} layer`, ErrorCategory.USER, [
+      'Use "model_show" to view the existing element',
+      'Use "model_update" to modify it',
+      'Use "model_delete" to remove it first if you want to recreate it'
+    ]);
+  isNewLayer && model.addLayer(layerObj);
+  const mutationHandler = new MutationHandler(model, elementPath, layer);
+  await mutationHandler.executeAdd(element, (elem) => {
+    layerObj.addElement(elem);
+  });
+  const activeChangeset = await mutationHandler.getStagingManager().getActive(), staged = !!(activeChangeset && activeChangeset.status === "staged");
+  return staged && !layerKnown && await reloadModel(rootPath), jsonResult({
+    status: staged ? "staged" : "added",
+    changeset: staged ? activeChangeset.name : void 0,
+    id: elementPath,
+    layer,
+    type: prepared.type,
+    name: spec.name,
+    ...prepared.warnings.length > 0 ? { warnings: prepared.warnings } : {}
+  });
+}
+async function addElementBatch(specs, relationships, rootPath) {
+  const model = await loadModel(rootPath), manager = new StagingAreaManager(model.rootPath, model), active = await activeStagedChangeset(manager), changeset = active ?? previewChangeset(), graph = await ChangesetGraph.build(model, changeset), prepared = [], pending = /* @__PURE__ */ new Map(), rejected = /* @__PURE__ */ new Map(), results = [];
+  for (const [index, spec] of specs.entries()) {
+    const asSent = { index, name: spec.name };
+    let item;
+    try {
+      item = await prepareElement(spec);
+    } catch (error) {
+      const id = idFor(spec);
+      id && rejected.set(id, getErrorMessage(error)), results.push({
+        ...asSent,
+        ...id ? { id } : {},
+        status: "invalid",
+        reason: getErrorMessage(error),
+        ...error instanceof CLIError && error.suggestions?.length ? { suggestions: error.suggestions } : {}
+      });
+      continue;
+    }
+    const existing = graph.getElement(item.id);
+    if (existing && existing.status !== "deleted") {
+      results.push({
+        ...asSent,
+        id: item.id,
+        status: "invalid",
+        reason: `Element ${item.id} already exists`,
+        suggestions: ['Use "model_update" to change it']
+      });
+      continue;
+    }
+    if (pending.has(item.id)) {
+      results.push({ ...asSent, id: item.id, status: "invalid", reason: "Repeated earlier in this batch" });
+      continue;
+    }
+    pending.set(item.id, { id: item.id, layer: item.layer, type: item.type }), prepared.push(item), results.push({
+      ...asSent,
+      id: item.id,
+      status: active ? "staged" : "added",
+      ...item.warnings.length > 0 ? { warnings: item.warnings } : {}
     });
+  }
+  const plan = await planRelationshipBatch(graph, changeset, relationships, {
+    pending,
+    rejected,
+    addStatus: active ? "staged" : "added"
   });
+  if (active) {
+    const elementChanges = prepared.map((p) => ({
+      type: "add",
+      elementId: p.id,
+      layerName: p.layer,
+      after: p.element.toJSON()
+    }));
+    await applyRelationshipPlan(model, manager, active, plan, elementChanges);
+  } else {
+    for (const p of prepared)
+      await writeElement(model, p);
+    await applyRelationshipPlan(model, manager, null, plan, []);
+  }
+  return (prepared.length > 0 || plan.changes.length > 0 || plan.unstageKeys.length > 0) && await reloadModel(rootPath), {
+    ...active ? { changeset: active.name } : {},
+    elements: { counts: countByStatus(results), results },
+    ...relationships.length > 0 ? { relationships: { counts: countByStatus(plan.results), results: plan.results } } : {}
+  };
+}
+async function writeElement(model, prepared) {
+  let layerObj = await model.getLayer(prepared.layer);
+  layerObj || (layerObj = new Layer(prepared.layer), model.addLayer(layerObj));
+  const target = layerObj;
+  await new MutationHandler(model, prepared.id, prepared.layer).executeAdd(prepared.element, (elem) => {
+    target.addElement(elem);
+  });
+}
+function idFor(spec) {
+  if (!isValidLayer(spec.layer) || !isValidNodeType(spec.layer, spec.type))
+    return;
+  const id = generateElementId(spec.layer, normalizeNodeType(spec.layer, spec.type), spec.name);
+  return id.split(".")[2] ? id : void 0;
 }
 const modelAddTool = {
   name: "model_add",
-  description: "Add a new element to a layer, validated against its spec schema.",
+  description: "Add elements, validated against their spec schemas. Send one (layer/type/name) or many (elements: [...], with optional relationships: [...] that may name the new elements); a list is staged in one write, so use it when adding several. A list returns a result per element and per relationship: staged (added, with no changeset active), restored or duplicate (relationships), or invalid with the reason. Invalid items are skipped; the rest are still staged.",
   inputSchema,
   handler: modelAddHandler
 };

package/dist/mcp/tools/model-add.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/mcp/tools/model-add.ts"],
-  "sourcesContent": ["/**\n * model_add \u2014 add an element to a layer. Mirrors `dr add`, operating through\n * the shared MutationHandler so staging and base-model persistence stay\n * consistent with the CLI.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { Element } from \"../../core/element.js\";\nimport { Layer } from \"../../core/layer.js\";\nimport { MutationHandler } from \"../../core/mutation-handler.js\";\nimport { getAllLayerIds, isValidLayer } from \"../../generated/layer-registry.js\";\nimport { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from \"../../generated/node-types.js\";\nimport { generateElementId, generateUUID } from \"../../utils/id-generator.js\";\nimport { buildSourceReference, validateSourceReferenceOptions } from \"../../utils/source-reference.js\";\nimport { schemaLookupHint } from \"../../utils/error-hints.js\";\nimport { SchemaValidator } from \"../../validators/schema-validator.js\";\nimport { CLIError, ErrorCategory, findSimilar, formatValidOptions } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  layer: z.string().describe(\"Canonical layer name (e.g. 'api', 'data-model').\"),\n  type: z.string().describe(\"Element type within the layer (e.g. 'operation', 'entity').\"),\n  name: z.string().describe(\"Human-readable element name; used to derive the element ID.\"),\n  description: z.string().optional(),\n  attributes: z.record(z.string(), z.unknown()).optional().describe(\"Type-specific attributes, validated against the element's spec schema.\"),\n  sourceFile: z.string().optional().describe(\"Source file path relative to the repository root.\"),\n  sourceSymbol: z.string().optional(),\n  sourceProvenance: z.enum([\"extracted\", \"manual\", \"inferred\", \"generated\"]).optional(),\n  sourceRepoRemote: z.string().optional(),\n  sourceRepoCommit: z.string().optional().describe(\"Full 40-character Git commit SHA.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelAddArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function modelAddHandler(args: ModelAddArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (!isValidLayer(args.layer)) {\n      const validLayers = getAllLayerIds();\n      const similar = findSimilar(args.layer, validLayers, 3);\n      const suggestions: string[] = [`Use a valid layer name: ${formatValidOptions(validLayers)}`];\n      if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n      throw new CLIError(`Unknown layer \"${args.layer}\"`, ErrorCategory.USER, suggestions);\n    }\n\n    if (!isValidNodeType(args.layer, args.type)) {\n      const validNodeTypes = getNodeTypesForLayer(args.layer);\n      const typeNames = validNodeTypes.map((t) => t.type).sort();\n      const similar = findSimilar(args.type, typeNames, 3);\n      const suggestions: string[] = [`Valid types for ${args.layer}: ${formatValidOptions(typeNames)}`];\n      if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n      throw new CLIError(`Invalid element type \"${args.type}\" for layer \"${args.layer}\"`, ErrorCategory.USER, suggestions);\n    }\n\n    const resolvedType = normalizeNodeType(args.layer, args.type);\n    const elementPath = generateElementId(args.layer, resolvedType, args.name);\n    const elementUUID = generateUUID();\n\n    const slugPart = elementPath.split(\".\")[2];\n    if (!slugPart) {\n      throw new CLIError(`Cannot generate a valid element ID from name \"${args.name}\"`, ErrorCategory.USER, [\n        \"Element names must contain at least one letter or digit\",\n      ]);\n    }\n\n    validateSourceReferenceOptions(args, \"mcp\");\n\n    const model = await loadModel(args.rootPath);\n\n    // Inside a changeset getLayer() projects even a layer the model has no elements in, so ask the\n    // model's layer list whether this layer is new to it.\n    const layerKnown = model.getLayerNames().includes(args.layer);\n    let layerObj = await model.getLayer(args.layer);\n    let isNewLayer = false;\n    if (!layerObj) {\n      layerObj = new Layer(args.layer);\n      isNewLayer = true;\n    }\n\n    const now = new Date().toISOString();\n    const element = new Element({\n      id: elementUUID,\n      path: elementPath,\n      spec_node_id: `${args.layer}.${resolvedType}`,\n      layer_id: args.layer,\n      type: resolvedType,\n      name: args.name,\n      description: args.description,\n      attributes: args.attributes ?? {},\n      metadata: {\n        created_at: now,\n        updated_at: now,\n        version: 1,\n      },\n      layer: args.layer,\n    });\n\n    const sourceRef = buildSourceReference(args);\n    if (sourceRef) {\n      element.setSourceReference(sourceRef);\n    }\n\n    {\n      const schemaValidator = new SchemaValidator();\n      const tempLayer = new Layer(args.layer);\n      tempLayer.addElement(element);\n      const attrValidation = await schemaValidator.validateLayer(tempLayer);\n      if (!attrValidation.isValid()) {\n        const errorMessages = attrValidation.errors.map((e) => `  ${e.message}`).join(\"\\n\");\n        throw new CLIError(`Element ${elementPath} has invalid attributes:\\n${errorMessages}`, ErrorCategory.USER, [\n          schemaLookupHint(\"mcp\", args.layer, resolvedType),\n        ]);\n      }\n    }\n\n    if (layerObj.getElement(elementPath)) {\n      throw new CLIError(`Element ${elementPath} already exists in ${args.layer} layer`, ErrorCategory.USER, [\n        `Use \"model_show\" to view the existing element`,\n        `Use \"model_update\" to modify it`,\n        `Use \"model_delete\" to remove it first if you want to recreate it`,\n      ]);\n    }\n\n    if (isNewLayer) {\n      model.addLayer(layerObj);\n    }\n\n    const mutationHandler = new MutationHandler(model, elementPath, args.layer);\n    await mutationHandler.executeAdd(element, (elem) => {\n      layerObj!.addElement(elem);\n    });\n\n    const stagingManager = mutationHandler.getStagingManager();\n    const activeChangeset = await stagingManager.getActive();\n    const staged = !!(activeChangeset && activeChangeset.status === \"staged\");\n    if (staged && !layerKnown) {\n      // The cached model did not list this layer: reread it so every later tool call\n      // (relationship_add, model_show, model_update, ...) sees the layer and the element.\n      await reloadModel(args.rootPath);\n    }\n\n    return jsonResult({\n      status: staged ? \"staged\" : \"added\",\n      changeset: staged ? activeChangeset!.name : undefined,\n      id: elementPath,\n      layer: args.layer,\n      type: resolvedType,\n      name: args.name,\n    });\n  });\n}\n\nexport const modelAddTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_add\",\n  description: \"Add a new element to a layer, validated against its spec schema.\",\n  inputSchema,\n  handler: modelAddHandler,\n};\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * model_add \u2014 add an element to a layer. Mirrors `dr add`, operating through\n * the shared MutationHandler so staging and base-model persistence stay\n * consistent with the CLI.\n *\n * It also takes a list (`elements`, with optional `relationships` between them and the model):\n * each item is validated on its own, and the valid ones are staged in one write. Invalid items\n * are skipped and reported.\n */\n\nimport { z } from \"zod\";\nimport { strictItem } from \"../strict-schema.js\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport type { StagedChange } from \"../../core/changeset.js\";\nimport { ChangesetGraph } from \"../../core/changeset-graph.js\";\nimport { Element } from \"../../core/element.js\";\nimport { Layer } from \"../../core/layer.js\";\nimport type { Model } from \"../../core/model.js\";\nimport { MutationHandler } from \"../../core/mutation-handler.js\";\nimport { countByStatus, planRelationshipBatch, type PendingElement } from \"../../core/relationship-staging.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { getAllLayerIds, isValidLayer } from \"../../generated/layer-registry.js\";\nimport { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from \"../../generated/node-types.js\";\nimport { generateElementId, generateUUID } from \"../../utils/id-generator.js\";\nimport { buildSourceReference, resolveSourceReferenceOptions } from \"../../utils/source-reference.js\";\nimport { schemaLookupHint } from \"../../utils/error-hints.js\";\nimport { SchemaValidator } from \"../../validators/schema-validator.js\";\nimport { CLIError, ErrorCategory, findSimilar, formatValidOptions, getErrorMessage } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport { activeStagedChangeset } from \"./changeset-shared.js\";\nimport { applyRelationshipPlan, previewChangeset, relationshipItemSchema } from \"./relationship-tools.js\";\n\nconst provenanceSchema = z\n  .enum([\"extracted\", \"manual\", \"inferred\", \"generated\"])\n  .optional()\n  .describe(\n    \"How the source reference was made. Defaults to 'manual' when sourceFile is sent alone. 'extracted' and \" +\n      \"'manual' need a sourceFile (sent without one, it is ignored with a warning). For a planned element with no \" +\n      \"code yet, send no source fields.\"\n  );\n\nconst elementFields = {\n  description: z.string().optional(),\n  attributes: z.record(z.string(), z.unknown()).optional().describe(\"Type-specific attributes, validated against the element's spec schema.\"),\n  sourceFile: z.string().optional().describe(\"Source file path relative to the repository root.\"),\n  sourceSymbol: z.string().optional(),\n  sourceProvenance: provenanceSchema,\n  sourceRepoRemote: z.string().optional(),\n  sourceRepoCommit: z.string().optional().describe(\"Full 40-character Git commit SHA.\"),\n};\n\nconst elementItemSchema = strictItem(\"An elements[] item\", {\n  layer: z.string().describe(\"Canonical layer name.\"),\n  type: z.string().describe(\"Element type within the layer.\"),\n  name: z.string().describe(\"Human-readable element name; used to derive the element ID.\"),\n  ...elementFields,\n});\n\nconst inputSchema = {\n  layer: z.string().optional().describe(\"Canonical layer name (e.g. 'api', 'data-model'). Single form.\"),\n  type: z.string().optional().describe(\"Element type within the layer (e.g. 'operation', 'entity'). Single form.\"),\n  name: z.string().optional().describe(\"Human-readable element name; used to derive the element ID. Single form.\"),\n  ...elementFields,\n  elements: z\n    .array(elementItemSchema)\n    .optional()\n    .describe(\n      \"Batch form, instead of layer/type/name: a list of elements ({layer, type, name, description?, attributes?, \" +\n        \"source fields?}), staged in one write. Each is validated on its own; an invalid one is skipped and reported.\"\n    ),\n  relationships: z\n    .array(relationshipItemSchema)\n    .optional()\n    .describe(\n      \"Batch form only: relationships to stage in the same write, as relationship_add takes them. They may name \" +\n        \"elements this call adds (by the id layer.type.kebab-name).\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelAddArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\n/** The single form's fields: refused beside `elements`, where they would otherwise be dropped. */\nconst SINGLE_FORM_FIELDS = [\n  \"layer\",\n  \"type\",\n  \"name\",\n  ...(Object.keys(elementFields) as Array<keyof typeof elementFields>),\n] as const;\ntype ElementSpec = z.infer<typeof elementItemSchema>;\n\ninterface PreparedElement {\n  element: Element;\n  id: string;\n  layer: string;\n  type: string;\n  warnings: string[];\n}\n\n/** Validates one element and builds it; throws a CLIError saying what is wrong. */\nasync function prepareElement(spec: ElementSpec): Promise<PreparedElement> {\n  if (!isValidLayer(spec.layer)) {\n    const validLayers = getAllLayerIds();\n    const similar = findSimilar(spec.layer, validLayers, 3);\n    const suggestions: string[] = [`Use a valid layer name: ${formatValidOptions(validLayers)}`];\n    if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n    throw new CLIError(`Unknown layer \"${spec.layer}\"`, ErrorCategory.USER, suggestions);\n  }\n\n  if (!isValidNodeType(spec.layer, spec.type)) {\n    const validNodeTypes = getNodeTypesForLayer(spec.layer);\n    const typeNames = validNodeTypes.map((t) => t.type).sort();\n    const similar = findSimilar(spec.type, typeNames, 3);\n    const suggestions: string[] = [`Valid types for ${spec.layer}: ${formatValidOptions(typeNames)}`];\n    if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n    throw new CLIError(`Invalid element type \"${spec.type}\" for layer \"${spec.layer}\"`, ErrorCategory.USER, suggestions);\n  }\n\n  const resolvedType = normalizeNodeType(spec.layer, spec.type);\n  const elementPath = generateElementId(spec.layer, resolvedType, spec.name);\n\n  const slugPart = elementPath.split(\".\")[2];\n  if (!slugPart) {\n    throw new CLIError(`Cannot generate a valid element ID from name \"${spec.name}\"`, ErrorCategory.USER, [\n      \"Element names must contain at least one letter or digit\",\n    ]);\n  }\n\n  const { options: sourceOptions, warnings } = resolveSourceReferenceOptions(spec, \"mcp\");\n\n  const now = new Date().toISOString();\n  const element = new Element({\n    id: generateUUID(),\n    path: elementPath,\n    spec_node_id: `${spec.layer}.${resolvedType}`,\n    layer_id: spec.layer,\n    type: resolvedType,\n    name: spec.name,\n    description: spec.description,\n    attributes: spec.attributes ?? {},\n    metadata: {\n      created_at: now,\n      updated_at: now,\n      version: 1,\n    },\n    layer: spec.layer,\n  });\n\n  const sourceRef = buildSourceReference(sourceOptions);\n  if (sourceRef) {\n    element.setSourceReference(sourceRef);\n  }\n\n  const schemaValidator = new SchemaValidator();\n  const tempLayer = new Layer(spec.layer);\n  tempLayer.addElement(element);\n  const attrValidation = await schemaValidator.validateLayer(tempLayer);\n  if (!attrValidation.isValid()) {\n    const errorMessages = attrValidation.errors.map((e) => `  ${e.message}`).join(\"\\n\");\n    throw new CLIError(`Element ${elementPath} has invalid attributes:\\n${errorMessages}`, ErrorCategory.USER, [\n      schemaLookupHint(\"mcp\", spec.layer, resolvedType),\n    ]);\n  }\n\n  return { element, id: elementPath, layer: spec.layer, type: resolvedType, warnings };\n}\n\nexport async function modelAddHandler(args: ModelAddArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (args.elements !== undefined) {\n      const singleFields = SINGLE_FORM_FIELDS.filter((field) => args[field] !== undefined);\n      if (singleFields.length > 0) {\n        throw new CLIError(\n          `Send either a single element or elements, not both (got ${singleFields.join(\", \")} beside elements)`,\n          ErrorCategory.USER,\n          [\"Put those fields on the items of the elements list\"]\n        );\n      }\n      return jsonResult(await addElementBatch(args.elements, args.relationships ?? [], args.rootPath));\n    }\n    if (args.relationships !== undefined) {\n      throw new CLIError(\"relationships goes with the elements list\", ErrorCategory.USER, [\n        \"Send {elements: [...], relationships: [...]}, or use relationship_add for relationships alone\",\n      ]);\n    }\n    if (!args.layer || !args.type || !args.name) {\n      throw new CLIError(\"model_add needs layer, type and name, or an elements list\", ErrorCategory.USER, [\n        'Single: {layer: \"api\", type: \"operation\", name: \"Create Order\"}',\n        \"Batch: {elements: [{layer, type, name}, ...], relationships: [{source, predicate, target}, ...]}\",\n      ]);\n    }\n    return addSingleElement({ ...args, layer: args.layer, type: args.type, name: args.name }, args.rootPath);\n  });\n}\n\nasync function addSingleElement(spec: ElementSpec, rootPath: string | undefined): Promise<CallToolResult> {\n  const prepared = await prepareElement(spec);\n  const { element, id: elementPath, layer } = prepared;\n\n  const model = await loadModel(rootPath);\n\n  // Inside a changeset getLayer() projects even a layer the model has no elements in, so ask the\n  // model's layer list whether this layer is new to it.\n  const layerKnown = model.getLayerNames().includes(layer);\n  let layerObj = await model.getLayer(layer);\n  let isNewLayer = false;\n  if (!layerObj) {\n    layerObj = new Layer(layer);\n    isNewLayer = true;\n  }\n\n  if (layerObj.getElement(elementPath)) {\n    throw new CLIError(`Element ${elementPath} already exists in ${layer} layer`, ErrorCategory.USER, [\n      `Use \"model_show\" to view the existing element`,\n      `Use \"model_update\" to modify it`,\n      `Use \"model_delete\" to remove it first if you want to recreate it`,\n    ]);\n  }\n\n  if (isNewLayer) {\n    model.addLayer(layerObj);\n  }\n\n  const mutationHandler = new MutationHandler(model, elementPath, layer);\n  await mutationHandler.executeAdd(element, (elem) => {\n    layerObj!.addElement(elem);\n  });\n\n  const stagingManager = mutationHandler.getStagingManager();\n  const activeChangeset = await stagingManager.getActive();\n  const staged = !!(activeChangeset && activeChangeset.status === \"staged\");\n  if (staged && !layerKnown) {\n    // The cached model did not list this layer: reread it so every later tool call\n    // (relationship_add, model_show, model_update, ...) sees the layer and the element.\n    await reloadModel(rootPath);\n  }\n\n  return jsonResult({\n    status: staged ? \"staged\" : \"added\",\n    changeset: staged ? activeChangeset!.name : undefined,\n    id: elementPath,\n    layer,\n    type: prepared.type,\n    name: spec.name,\n    ...(prepared.warnings.length > 0 ? { warnings: prepared.warnings } : {}),\n  });\n}\n\ninterface ElementBatchResult {\n  index: number;\n  id?: string;\n  name: string;\n  status: \"staged\" | \"added\" | \"invalid\";\n  reason?: string;\n  suggestions?: string[];\n  warnings?: string[];\n}\n\n/**\n * model_add's batch form: validate every element and relationship, then stage the valid ones in\n * one write (or, with no active changeset, write them to the model).\n */\nasync function addElementBatch(\n  specs: ElementSpec[],\n  relationships: z.infer<typeof relationshipItemSchema>[],\n  rootPath: string | undefined\n) {\n  const model = await loadModel(rootPath);\n  const manager = new StagingAreaManager(model.rootPath, model);\n  const active = await activeStagedChangeset(manager);\n  const changeset = active ?? previewChangeset();\n  const graph = await ChangesetGraph.build(model, changeset);\n\n  const prepared: PreparedElement[] = [];\n  const pending = new Map<string, PendingElement>();\n  const rejected = new Map<string, string>();\n  const results: ElementBatchResult[] = [];\n\n  for (const [index, spec] of specs.entries()) {\n    const asSent = { index, name: spec.name };\n    let item: PreparedElement;\n    try {\n      item = await prepareElement(spec);\n    } catch (error) {\n      const id = idFor(spec);\n      if (id) rejected.set(id, getErrorMessage(error));\n      results.push({\n        ...asSent,\n        ...(id ? { id } : {}),\n        status: \"invalid\",\n        reason: getErrorMessage(error),\n        ...(error instanceof CLIError && error.suggestions?.length ? { suggestions: error.suggestions } : {}),\n      });\n      continue;\n    }\n    const existing = graph.getElement(item.id);\n    if (existing && existing.status !== \"deleted\") {\n      results.push({\n        ...asSent,\n        id: item.id,\n        status: \"invalid\",\n        reason: `Element ${item.id} already exists`,\n        suggestions: ['Use \"model_update\" to change it'],\n      });\n      continue;\n    }\n    if (pending.has(item.id)) {\n      results.push({ ...asSent, id: item.id, status: \"invalid\", reason: \"Repeated earlier in this batch\" });\n      continue;\n    }\n    pending.set(item.id, { id: item.id, layer: item.layer, type: item.type });\n    prepared.push(item);\n    results.push({\n      ...asSent,\n      id: item.id,\n      status: active ? \"staged\" : \"added\",\n      ...(item.warnings.length > 0 ? { warnings: item.warnings } : {}),\n    });\n  }\n\n  const plan = await planRelationshipBatch(graph, changeset, relationships, {\n    pending,\n    rejected,\n    addStatus: active ? \"staged\" : \"added\",\n  });\n\n  if (active) {\n    const elementChanges: Array<Omit<StagedChange, \"sequenceNumber\">> = prepared.map((p) => ({\n      type: \"add\",\n      elementId: p.id,\n      layerName: p.layer,\n      after: p.element.toJSON() as unknown as Record<string, unknown>,\n    }));\n    await applyRelationshipPlan(model, manager, active, plan, elementChanges);\n  } else {\n    for (const p of prepared) {\n      await writeElement(model, p);\n    }\n    await applyRelationshipPlan(model, manager, null, plan, []);\n  }\n  if (prepared.length > 0 || plan.changes.length > 0 || plan.unstageKeys.length > 0) {\n    await reloadModel(rootPath);\n  }\n\n  return {\n    ...(active ? { changeset: active.name } : {}),\n    elements: { counts: countByStatus(results), results },\n    ...(relationships.length > 0\n      ? { relationships: { counts: countByStatus(plan.results), results: plan.results } }\n      : {}),\n  };\n}\n\n/** Writes one element to the base model (no changeset is active). */\nasync function writeElement(model: Model, prepared: PreparedElement): Promise<void> {\n  let layerObj = await model.getLayer(prepared.layer);\n  if (!layerObj) {\n    layerObj = new Layer(prepared.layer);\n    model.addLayer(layerObj);\n  }\n  const target = layerObj;\n  const handler = new MutationHandler(model, prepared.id, prepared.layer);\n  await handler.executeAdd(prepared.element, (elem) => {\n    target.addElement(elem);\n  });\n}\n\n/** The id an element spec would get, when its layer and type are valid. */\nfunction idFor(spec: ElementSpec): string | undefined {\n  if (!isValidLayer(spec.layer) || !isValidNodeType(spec.layer, spec.type)) return undefined;\n  const id = generateElementId(spec.layer, normalizeNodeType(spec.layer, spec.type), spec.name);\n  return id.split(\".\")[2] ? id : undefined;\n}\n\nexport const modelAddTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_add\",\n  description:\n    \"Add elements, validated against their spec schemas. Send one (layer/type/name) or many (elements: [...], \" +\n    \"with optional relationships: [...] that may name the new elements); a list is staged in one write, so use it \" +\n    \"when adding several. A list returns a result per element and per relationship: staged (added, with no \" +\n    \"changeset active), restored or duplicate (relationships), or invalid with the reason. Invalid items are \" +\n    \"skipped; the rest are still staged.\",\n  inputSchema,\n  handler: modelAddHandler,\n};\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/mcp/tools/model-update.js

@@ -5,7 +5,7 @@ import { MutationHandler } from "../../core/mutation-handler.js";
 import { setStagedSourceReference } from "../../core/staged-source-reference.js";
 import { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from "../../generated/node-types.js";
 import { findElementLayer } from "../../utils/element-utils.js";
-import { buildSourceReference, validateSourceReferenceOptions } from "../../utils/source-reference.js";
+import { buildSourceReference, precheckUpdateSourceReferenceOptions, resolveSourceReferenceOptions } from "../../utils/source-reference.js";
 import { schemaLookupHint, undefinedTypeWarning } from "../../utils/error-hints.js";
 import { SchemaValidator, suggestNodeTypes } from "../../validators/schema-validator.js";
 import { CLIError, ErrorCategory, findSimilar, formatValidOptions } from "../../utils/errors.js";
@@ -19,8 +19,8 @@ const inputSchema = {
   attributes: z.record(z.string(), z.unknown()).optional().describe("Replaces the element's attributes, validated against its spec schema."),
   attributePatch: z.record(z.string(), z.unknown()).optional().describe("Merged into the element's current attributes (as the active changeset leaves them), so required attributes need not be repeated; a null value removes that key. The merged result is validated against the spec schema. Cannot be combined with attributes."),
   sourceFile: z.string().optional(),
-  sourceSymbol: z.string().optional(),
-  sourceProvenance: z.enum(["extracted", "manual", "inferred", "generated"]).optional(),
+  sourceSymbol: z.string().optional().describe("Sent without sourceFile, goes on the element's source file and keeps its provenance: on its one location when that has no symbol, else added beside the symbols the file already has (never twice). An element with no source file, or several, needs sourceFile with it."),
+  sourceProvenance: z.enum(["extracted", "manual", "inferred", "generated"]).optional().describe("Sent alone, changes the provenance and keeps the element's file. A sourceFile sent alone keeps the current provenance, or gets 'manual'. 'extracted' and 'manual' need a file (on the element or sent): without one they are ignored with a warning."),
   sourceRepoRemote: z.string().optional(),
   sourceRepoCommit: z.string().optional().describe("Full 40-character Git commit SHA."),
   clearSourceReference: z.boolean().optional().describe("Remove the element's source reference. Cannot be combined with other source options."),
@@ -32,7 +32,7 @@ function validateUpdateSourceReferenceOptions(args) {
     throw new CLIError("Cannot use clearSourceReference with other source reference options", ErrorCategory.USER, [
       "Specify either clearSourceReference or other source options, not both"
     ]);
-  hasSourceOptions && validateSourceReferenceOptions(args, "mcp");
+  hasSourceOptions && precheckUpdateSourceReferenceOptions(args, "mcp");
 }
 async function modelUpdateHandler(args) {
   return runTool(async () => {
@@ -47,9 +47,15 @@ async function modelUpdateHandler(args) {
       throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [
         'Use "model_search" to find similar elements'
       ]);
-    if (!(args.name || args.description !== void 0 || args.type || args.attributes || attributePatch || args.sourceFile || args.sourceSymbol || args.sourceProvenance || args.sourceRepoRemote || args.sourceRepoCommit || args.clearSourceReference))
-      return jsonResult({ status: "no-op", id: args.id, message: "No fields specified for update" });
-    const mutationHandler = new MutationHandler(model, args.id, layerName), warnings = [];
+    const currentSource = element.getSourceReference(), source = resolveSourceReferenceOptions(args, "mcp", currentSource), warnings = [...source.warnings];
+    if (!(args.name || args.description !== void 0 || args.type || args.attributes || attributePatch || source.options.sourceProvenance || args.clearSourceReference))
+      return jsonResult({
+        status: "no-op",
+        id: args.id,
+        message: warnings.length > 0 ? "Nothing left to update" : "No fields specified for update",
+        ...warnings.length > 0 ? { warnings } : {}
+      });
+    const mutationHandler = new MutationHandler(model, args.id, layerName);
     await mutationHandler.executeUpdate(element, async (elem, after) => {
       let resolvedNewType;
       if (args.type) {
@@ -85,12 +91,10 @@ ${errorMessages}`, ErrorCategory.USER, [
           ]);
         }
       }
-      resolvedNewType && (elem.type = resolvedNewType, after.type = resolvedNewType, elem.spec_node_id = `${layerName}.${resolvedNewType}`, after.spec_node_id = `${layerName}.${resolvedNewType}`), args.name && (elem.name = args.name, after.name = args.name), args.description !== void 0 && (elem.description = args.description || void 0, after.description = args.description || void 0), newAttributes && (elem.attributes = newAttributes, after.attributes = newAttributes);
-      const hasSourceReferenceUpdate = args.sourceFile || args.sourceSymbol || args.sourceProvenance || args.sourceRepoRemote || args.sourceRepoCommit;
-      if (args.clearSourceReference)
+      if (resolvedNewType && (elem.type = resolvedNewType, after.type = resolvedNewType, elem.spec_node_id = `${layerName}.${resolvedNewType}`, after.spec_node_id = `${layerName}.${resolvedNewType}`), args.name && (elem.name = args.name, after.name = args.name), args.description !== void 0 && (elem.description = args.description || void 0, after.description = args.description || void 0), newAttributes && (elem.attributes = newAttributes, after.attributes = newAttributes), args.clearSourceReference)
         elem.setSourceReference(void 0), setStagedSourceReference(after, void 0);
-      else if (hasSourceReferenceUpdate) {
-        const newRef = buildSourceReference(args);
+      else if (source.options.sourceProvenance) {
+        const newRef = buildSourceReference(source.options, currentSource);
         newRef && (elem.setSourceReference(newRef), setStagedSourceReference(after, newRef));
       }
       layer.updateElement(elem);

package/dist/mcp/tools/model-update.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/mcp/tools/model-update.ts"],
-  "sourcesContent": ["/**\n * model_update \u2014 update an existing element. Mirrors `dr update`, operating\n * through the shared MutationHandler.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { Element } from \"../../core/element.js\";\nimport { Layer } from \"../../core/layer.js\";\nimport { MutationHandler } from \"../../core/mutation-handler.js\";\nimport { setStagedSourceReference } from \"../../core/staged-source-reference.js\";\nimport { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from \"../../generated/node-types.js\";\nimport { findElementLayer } from \"../../utils/element-utils.js\";\nimport { buildSourceReference, validateSourceReferenceOptions } from \"../../utils/source-reference.js\";\nimport { schemaLookupHint, undefinedTypeWarning } from \"../../utils/error-hints.js\";\nimport { SchemaValidator, suggestNodeTypes } from \"../../validators/schema-validator.js\";\nimport { CLIError, ErrorCategory, findSimilar, formatValidOptions } from \"../../utils/errors.js\";\nimport { effectiveAttributePatch, resolveAttributeUpdate } from \"../../utils/attribute-patch.js\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  id: z.string().describe(\"Element ID or path to update.\"),\n  name: z.string().optional(),\n  description: z.string().optional(),\n  type: z.string().optional().describe(\"New element type within the current layer.\"),\n  attributes: z.record(z.string(), z.unknown()).optional().describe(\"Replaces the element's attributes, validated against its spec schema.\"),\n  attributePatch: z\n    .record(z.string(), z.unknown())\n    .optional()\n    .describe(\n      \"Merged into the element's current attributes (as the active changeset leaves them), so required attributes \" +\n        \"need not be repeated; a null value removes that key. The merged result is validated against the spec \" +\n        \"schema. Cannot be combined with attributes.\"\n    ),\n  sourceFile: z.string().optional(),\n  sourceSymbol: z.string().optional(),\n  sourceProvenance: z.enum([\"extracted\", \"manual\", \"inferred\", \"generated\"]).optional(),\n  sourceRepoRemote: z.string().optional(),\n  sourceRepoCommit: z.string().optional().describe(\"Full 40-character Git commit SHA.\"),\n  clearSourceReference: z.boolean().optional().describe(\"Remove the element's source reference. Cannot be combined with other source options.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelUpdateArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nfunction validateUpdateSourceReferenceOptions(args: ModelUpdateArgs): void {\n  const hasSourceOptions =\n    args.sourceFile || args.sourceSymbol || args.sourceProvenance || args.sourceRepoRemote || args.sourceRepoCommit;\n\n  if (args.clearSourceReference && hasSourceOptions) {\n    throw new CLIError(\"Cannot use clearSourceReference with other source reference options\", ErrorCategory.USER, [\n      \"Specify either clearSourceReference or other source options, not both\",\n    ]);\n  }\n\n  if (hasSourceOptions) {\n    validateSourceReferenceOptions(args, \"mcp\");\n  }\n}\n\nexport async function modelUpdateHandler(args: ModelUpdateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    validateUpdateSourceReferenceOptions(args);\n    // Refuse attributes + attributePatch before touching the model.\n    resolveAttributeUpdate(undefined, { attributes: args.attributes, attributePatch: args.attributePatch });\n    // An empty patch names no key: it is not an update.\n    const attributePatch = effectiveAttributePatch(args.attributePatch);\n\n    const model = await loadModel(args.rootPath);\n\n    const layerName = await findElementLayer(model, args.id);\n    if (!layerName) {\n      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"model_search\" to find similar elements',\n      ]);\n    }\n\n    const layer = await model.getLayer(layerName);\n    const element = layer?.getElement(args.id);\n    if (!layer || !element) {\n      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"model_search\" to find similar elements',\n      ]);\n    }\n\n    const hasUpdates =\n      args.name ||\n      args.description !== undefined ||\n      args.type ||\n      args.attributes ||\n      attributePatch ||\n      args.sourceFile ||\n      args.sourceSymbol ||\n      args.sourceProvenance ||\n      args.sourceRepoRemote ||\n      args.sourceRepoCommit ||\n      args.clearSourceReference;\n\n    if (!hasUpdates) {\n      return jsonResult({ status: \"no-op\", id: args.id, message: \"No fields specified for update\" });\n    }\n\n    const mutationHandler = new MutationHandler(model, args.id, layerName);\n    const warnings: string[] = [];\n\n    await mutationHandler.executeUpdate(element, async (elem, after) => {\n      let resolvedNewType: string | undefined;\n      if (args.type) {\n        if (!isValidNodeType(layerName, args.type)) {\n          const validNodeTypes = getNodeTypesForLayer(layerName);\n          const typeNames = validNodeTypes.map((t) => t.type).sort();\n          const similar = findSimilar(args.type!, typeNames, 3);\n          const suggestions: string[] = [`Valid types for ${layerName}: ${formatValidOptions(typeNames)}`];\n          if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n          throw new CLIError(`Invalid element type \"${args.type}\" for layer \"${layerName}\"`, ErrorCategory.USER, suggestions);\n        }\n        resolvedNewType = normalizeNodeType(layerName, args.type);\n      }\n\n      // The element is the projected one, so a patch merges over attributes the changeset already staged.\n      const newAttributes = resolveAttributeUpdate(elem.attributes, {\n        attributes: args.attributes,\n        attributePatch,\n      });\n\n      if (resolvedNewType || newAttributes) {\n        const candidateType = resolvedNewType ?? elem.type;\n        const tempElem = new Element({\n          ...elem.toJSON(),\n          type: candidateType,\n          spec_node_id: `${layerName}.${candidateType}`,\n          attributes: newAttributes ?? elem.attributes,\n        });\n        const schemaValidator = new SchemaValidator();\n        const tempLayer = new Layer(layerName);\n        tempLayer.addElement(tempElem);\n        const attrValidation = await schemaValidator.validateLayer(tempLayer);\n        // An element already of a type the spec no longer defines (no type change requested):\n        // its attributes have no type schema to fail, so let the update through and say how to\n        // retype it, rather than refusing with a spec_type hint that cannot work.\n        const undefinedType = !isValidNodeType(layerName, candidateType);\n        const blocking = undefinedType\n          ? attrValidation.errors.filter((e) => e.location !== \"/type\")\n          : attrValidation.errors;\n        if (undefinedType) {\n          const { message, hint } = undefinedTypeWarning(\n            \"mcp\",\n            layerName,\n            args.id,\n            candidateType,\n            suggestNodeTypes(layerName, candidateType)\n          );\n          warnings.push(`${message}. ${hint}`);\n        }\n        if (blocking.length > 0) {\n          const errorMessages = blocking.map((e) => `  ${e.message}`).join(\"\\n\");\n          throw new CLIError(`Updated attributes fail schema validation:\\n${errorMessages}`, ErrorCategory.USER, [\n            ...(undefinedType ? warnings : [schemaLookupHint(\"mcp\", layerName, candidateType)]),\n          ]);\n        }\n      }\n\n      if (resolvedNewType) {\n        elem.type = resolvedNewType;\n        after.type = resolvedNewType;\n        elem.spec_node_id = `${layerName}.${resolvedNewType}`;\n        after.spec_node_id = `${layerName}.${resolvedNewType}`;\n      }\n\n      if (args.name) {\n        elem.name = args.name;\n        after.name = args.name;\n      }\n\n      if (args.description !== undefined) {\n        elem.description = args.description || undefined;\n        after.description = args.description || undefined;\n      }\n\n      if (newAttributes) {\n        elem.attributes = newAttributes;\n        after.attributes = newAttributes;\n      }\n\n      const hasSourceReferenceUpdate =\n        args.sourceFile || args.sourceSymbol || args.sourceProvenance || args.sourceRepoRemote || args.sourceRepoCommit;\n\n      if (args.clearSourceReference) {\n        elem.setSourceReference(undefined);\n        setStagedSourceReference(after, undefined);\n      } else if (hasSourceReferenceUpdate) {\n        const newRef = buildSourceReference(args);\n        if (newRef) {\n          elem.setSourceReference(newRef);\n          setStagedSourceReference(after, newRef);\n        }\n      }\n\n      layer.updateElement(elem);\n    });\n\n    // The handler mutated the cached (projected) element in place; reread so the next call projects\n    // from what is on disk, staged or written.\n    await reloadModel(args.rootPath);\n\n    const stagingManager = mutationHandler.getStagingManager();\n    const activeChangeset = await stagingManager.getActive();\n    const staged = !!(activeChangeset && activeChangeset.status === \"staged\");\n\n    return jsonResult({\n      status: staged ? \"staged\" : \"updated\",\n      changeset: staged ? activeChangeset!.name : undefined,\n      id: args.id,\n      layer: layerName,\n      changedFields: mutationHandler.getChangedFields(),\n      // The changeset adds this element: the update was folded into that add (no separate change).\n      ...(mutationHandler.wasFoldedIntoAdd() ? { foldedIntoAdd: true } : {}),\n      ...(warnings.length > 0 ? { warnings } : {}),\n    });\n  });\n}\n\nexport const modelUpdateTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_update\",\n  description:\n    \"Update an existing element's name, description, type, attributes, or source reference. attributes replaces \" +\n    \"all attributes; attributePatch changes only the keys it names (null removes one).\",\n  inputSchema,\n  handler: modelUpdateHandler,\n};\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * model_update \u2014 update an existing element. Mirrors `dr update`, operating\n * through the shared MutationHandler.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { Element } from \"../../core/element.js\";\nimport { Layer } from \"../../core/layer.js\";\nimport { MutationHandler } from \"../../core/mutation-handler.js\";\nimport { setStagedSourceReference } from \"../../core/staged-source-reference.js\";\nimport { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from \"../../generated/node-types.js\";\nimport { findElementLayer } from \"../../utils/element-utils.js\";\nimport {\n  buildSourceReference,\n  precheckUpdateSourceReferenceOptions,\n  resolveSourceReferenceOptions,\n} from \"../../utils/source-reference.js\";\nimport { schemaLookupHint, undefinedTypeWarning } from \"../../utils/error-hints.js\";\nimport { SchemaValidator, suggestNodeTypes } from \"../../validators/schema-validator.js\";\nimport { CLIError, ErrorCategory, findSimilar, formatValidOptions } from \"../../utils/errors.js\";\nimport { effectiveAttributePatch, resolveAttributeUpdate } from \"../../utils/attribute-patch.js\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  id: z.string().describe(\"Element ID or path to update.\"),\n  name: z.string().optional(),\n  description: z.string().optional(),\n  type: z.string().optional().describe(\"New element type within the current layer.\"),\n  attributes: z.record(z.string(), z.unknown()).optional().describe(\"Replaces the element's attributes, validated against its spec schema.\"),\n  attributePatch: z\n    .record(z.string(), z.unknown())\n    .optional()\n    .describe(\n      \"Merged into the element's current attributes (as the active changeset leaves them), so required attributes \" +\n        \"need not be repeated; a null value removes that key. The merged result is validated against the spec \" +\n        \"schema. Cannot be combined with attributes.\"\n    ),\n  sourceFile: z.string().optional(),\n  sourceSymbol: z\n    .string()\n    .optional()\n    .describe(\n      \"Sent without sourceFile, goes on the element's source file and keeps its provenance: on its one location \" +\n        \"when that has no symbol, else added beside the symbols the file already has (never twice). An element \" +\n        \"with no source file, or several, needs sourceFile with it.\"\n    ),\n  sourceProvenance: z\n    .enum([\"extracted\", \"manual\", \"inferred\", \"generated\"])\n    .optional()\n    .describe(\n      \"Sent alone, changes the provenance and keeps the element's file. A sourceFile sent alone keeps the current \" +\n        \"provenance, or gets 'manual'. 'extracted' and 'manual' need a file (on the element or sent): without one \" +\n        \"they are ignored with a warning.\"\n    ),\n  sourceRepoRemote: z.string().optional(),\n  sourceRepoCommit: z.string().optional().describe(\"Full 40-character Git commit SHA.\"),\n  clearSourceReference: z.boolean().optional().describe(\"Remove the element's source reference. Cannot be combined with other source options.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelUpdateArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nfunction validateUpdateSourceReferenceOptions(args: ModelUpdateArgs): void {\n  const hasSourceOptions =\n    args.sourceFile || args.sourceSymbol || args.sourceProvenance || args.sourceRepoRemote || args.sourceRepoCommit;\n\n  if (args.clearSourceReference && hasSourceOptions) {\n    throw new CLIError(\"Cannot use clearSourceReference with other source reference options\", ErrorCategory.USER, [\n      \"Specify either clearSourceReference or other source options, not both\",\n    ]);\n  }\n\n  if (hasSourceOptions) {\n    // Refuse what cannot be settled before touching the model; the partial forms are settled\n    // against the element's current reference once it is loaded.\n    precheckUpdateSourceReferenceOptions(args, \"mcp\");\n  }\n}\n\nexport async function modelUpdateHandler(args: ModelUpdateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    validateUpdateSourceReferenceOptions(args);\n    // Refuse attributes + attributePatch before touching the model.\n    resolveAttributeUpdate(undefined, { attributes: args.attributes, attributePatch: args.attributePatch });\n    // An empty patch names no key: it is not an update.\n    const attributePatch = effectiveAttributePatch(args.attributePatch);\n\n    const model = await loadModel(args.rootPath);\n\n    const layerName = await findElementLayer(model, args.id);\n    if (!layerName) {\n      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"model_search\" to find similar elements',\n      ]);\n    }\n\n    const layer = await model.getLayer(layerName);\n    const element = layer?.getElement(args.id);\n    if (!layer || !element) {\n      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"model_search\" to find similar elements',\n      ]);\n    }\n\n    // Settle partial source fields first: one that is ignored (with a warning) is not an update.\n    const currentSource = element.getSourceReference();\n    const source = resolveSourceReferenceOptions(args, \"mcp\", currentSource);\n    const warnings: string[] = [...source.warnings];\n\n    const hasUpdates =\n      args.name ||\n      args.description !== undefined ||\n      args.type ||\n      args.attributes ||\n      attributePatch ||\n      source.options.sourceProvenance ||\n      args.clearSourceReference;\n\n    if (!hasUpdates) {\n      return jsonResult({\n        status: \"no-op\",\n        id: args.id,\n        message: warnings.length > 0 ? \"Nothing left to update\" : \"No fields specified for update\",\n        ...(warnings.length > 0 ? { warnings } : {}),\n      });\n    }\n\n    const mutationHandler = new MutationHandler(model, args.id, layerName);\n\n    await mutationHandler.executeUpdate(element, async (elem, after) => {\n      let resolvedNewType: string | undefined;\n      if (args.type) {\n        if (!isValidNodeType(layerName, args.type)) {\n          const validNodeTypes = getNodeTypesForLayer(layerName);\n          const typeNames = validNodeTypes.map((t) => t.type).sort();\n          const similar = findSimilar(args.type!, typeNames, 3);\n          const suggestions: string[] = [`Valid types for ${layerName}: ${formatValidOptions(typeNames)}`];\n          if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n          throw new CLIError(`Invalid element type \"${args.type}\" for layer \"${layerName}\"`, ErrorCategory.USER, suggestions);\n        }\n        resolvedNewType = normalizeNodeType(layerName, args.type);\n      }\n\n      // The element is the projected one, so a patch merges over attributes the changeset already staged.\n      const newAttributes = resolveAttributeUpdate(elem.attributes, {\n        attributes: args.attributes,\n        attributePatch,\n      });\n\n      if (resolvedNewType || newAttributes) {\n        const candidateType = resolvedNewType ?? elem.type;\n        const tempElem = new Element({\n          ...elem.toJSON(),\n          type: candidateType,\n          spec_node_id: `${layerName}.${candidateType}`,\n          attributes: newAttributes ?? elem.attributes,\n        });\n        const schemaValidator = new SchemaValidator();\n        const tempLayer = new Layer(layerName);\n        tempLayer.addElement(tempElem);\n        const attrValidation = await schemaValidator.validateLayer(tempLayer);\n        // An element already of a type the spec no longer defines (no type change requested):\n        // its attributes have no type schema to fail, so let the update through and say how to\n        // retype it, rather than refusing with a spec_type hint that cannot work.\n        const undefinedType = !isValidNodeType(layerName, candidateType);\n        const blocking = undefinedType\n          ? attrValidation.errors.filter((e) => e.location !== \"/type\")\n          : attrValidation.errors;\n        if (undefinedType) {\n          const { message, hint } = undefinedTypeWarning(\n            \"mcp\",\n            layerName,\n            args.id,\n            candidateType,\n            suggestNodeTypes(layerName, candidateType)\n          );\n          warnings.push(`${message}. ${hint}`);\n        }\n        if (blocking.length > 0) {\n          const errorMessages = blocking.map((e) => `  ${e.message}`).join(\"\\n\");\n          throw new CLIError(`Updated attributes fail schema validation:\\n${errorMessages}`, ErrorCategory.USER, [\n            ...(undefinedType ? warnings : [schemaLookupHint(\"mcp\", layerName, candidateType)]),\n          ]);\n        }\n      }\n\n      if (resolvedNewType) {\n        elem.type = resolvedNewType;\n        after.type = resolvedNewType;\n        elem.spec_node_id = `${layerName}.${resolvedNewType}`;\n        after.spec_node_id = `${layerName}.${resolvedNewType}`;\n      }\n\n      if (args.name) {\n        elem.name = args.name;\n        after.name = args.name;\n      }\n\n      if (args.description !== undefined) {\n        elem.description = args.description || undefined;\n        after.description = args.description || undefined;\n      }\n\n      if (newAttributes) {\n        elem.attributes = newAttributes;\n        after.attributes = newAttributes;\n      }\n\n      if (args.clearSourceReference) {\n        elem.setSourceReference(undefined);\n        setStagedSourceReference(after, undefined);\n      } else if (source.options.sourceProvenance) {\n        const newRef = buildSourceReference(source.options, currentSource);\n        if (newRef) {\n          elem.setSourceReference(newRef);\n          setStagedSourceReference(after, newRef);\n        }\n      }\n\n      layer.updateElement(elem);\n    });\n\n    // The handler mutated the cached (projected) element in place; reread so the next call projects\n    // from what is on disk, staged or written.\n    await reloadModel(args.rootPath);\n\n    const stagingManager = mutationHandler.getStagingManager();\n    const activeChangeset = await stagingManager.getActive();\n    const staged = !!(activeChangeset && activeChangeset.status === \"staged\");\n\n    return jsonResult({\n      status: staged ? \"staged\" : \"updated\",\n      changeset: staged ? activeChangeset!.name : undefined,\n      id: args.id,\n      layer: layerName,\n      changedFields: mutationHandler.getChangedFields(),\n      // The changeset adds this element: the update was folded into that add (no separate change).\n      ...(mutationHandler.wasFoldedIntoAdd() ? { foldedIntoAdd: true } : {}),\n      ...(warnings.length > 0 ? { warnings } : {}),\n    });\n  });\n}\n\nexport const modelUpdateTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_update\",\n  description:\n    \"Update an existing element's name, description, type, attributes, or source reference. attributes replaces \" +\n    \"all attributes; attributePatch changes only the keys it names (null removes one).\",\n  inputSchema,\n  handler: modelUpdateHandler,\n};\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/mcp/tools/model-validate.js

@@ -13,7 +13,7 @@ const inputSchema = {
 async function modelValidateHandler(args) {
   return runTool(async () => {
     const model = await loadModel(args.rootPath), activeChangesetId = model.getActiveChangesetId();
-    let modelToValidate = activeChangesetId ? { ...await model.getVirtualProjectionEngine().projectModel(model, activeChangesetId), rootPath: model.rootPath } : model;
+    let modelToValidate = activeChangesetId ? { ...await model.getVirtualProjectionEngine().projectModel(model, activeChangesetId), rootPath: model.rootPath } : model, outOfScopeIssues = [];
     if (args.layers && args.layers.length > 0) {
       const unknownLayers = args.layers.filter((name) => !isValidLayer(name));
       if (unknownLayers.length > 0) {
@@ -25,9 +25,10 @@ async function modelValidateHandler(args) {
         throw new CLIError(`Unknown layer(s): ${unknownLayers.join(", ")}`, ErrorCategory.USER, suggestions);
       }
       const requestedLayers = new Set(args.layers);
-      modelToValidate = {
+      outOfScopeIssues = danglingOutOfScopeEnds(modelToValidate, requestedLayers), modelToValidate = {
         ...modelToValidate,
-        layers: new Map(Array.from(modelToValidate.layers.entries()).filter(([name]) => requestedLayers.has(name)))
+        layers: new Map(Array.from(modelToValidate.layers.entries()).filter(([name]) => requestedLayers.has(name))),
+        loadedLayerFilter: [...requestedLayers]
       };
     }
     if (args.orphans) {
@@ -37,7 +38,10 @@ async function modelValidateHandler(args) {
         orphanedElements: stats2.orphanedElements
       });
     }
-    const result = await new Validator().validateModel(modelToValidate), stats = ValidationFormatter.calculateStats(modelToValidate);
+    const result = await new Validator().validateModel(modelToValidate);
+    for (const issue of outOfScopeIssues)
+      result.addError(issue);
+    const stats = ValidationFormatter.calculateStats(modelToValidate);
     for (const orphanId of stats.orphanedElements)
       result.addWarning({
         message: `Element '${orphanId}' is orphaned (no cross-layer references or intra-layer relationships)`,
@@ -65,6 +69,44 @@ async function modelValidateHandler(args) {
     return jsonResult({ ...formatted, valid });
   });
 }
+function danglingOutOfScopeEnds(model, scope) {
+  const known = /* @__PURE__ */ new Set();
+  for (const layer of model.layers.values())
+    for (const element of layer.listElements())
+      known.add(element.id), element.path && known.add(element.path);
+  const layerOf = (id) => id.split(".")[0] ?? "", referenceLayerOf = (id) => {
+    const separator = id.includes(".") ? "." : "-";
+    return [...getAllLayerIds()].sort((a, b) => b.length - a.length).find((name) => id.startsWith(name + separator)) ?? id.split(separator)[0] ?? "";
+  }, issues = [];
+  for (const rel of model.relationships.getAll()) {
+    if (!rel.source.includes(".") || !rel.target.includes("."))
+      continue;
+    const sourceIn = scope.has(layerOf(rel.source)), targetIn = scope.has(layerOf(rel.target));
+    if (sourceIn === targetIn)
+      continue;
+    const [end, role] = sourceIn ? [rel.target, "target"] : [rel.source, "source"];
+    known.has(end) || issues.push({
+      layer: rel.layer || layerOf(rel.source),
+      elementId: end,
+      message: `[Relationship Schema]: Relationship ${role} element '${end}' not found (outside the validated layers, and not in the model)`,
+      category: "reference"
+    });
+  }
+  for (const [layerName, layer] of model.layers)
+    if (scope.has(layerName))
+      for (const element of layer.listElements())
+        for (const ref of element.references ?? []) {
+          const destination = ref.target;
+          !destination || destination.startsWith("@") || scope.has(referenceLayerOf(destination)) || known.has(destination) || issues.push({
+            layer: layerName,
+            elementId: element.path || element.id,
+            message: `Broken reference: target '${destination}' does not exist (outside the validated layers, and not in the model)`,
+            fixSuggestion: `Remove reference or create element '${destination}'`,
+            category: "reference"
+          });
+        }
+  return issues;
+}
 const modelValidateTool = {
   name: "model_validate",
   description: "Run the full schema/naming/reference/semantic/relationship validation pipeline against the model.",