@documentation-robotics/cli 0.1.13 → 0.3.0

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

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { Element } from "../../core/element.js";
+import { Layer } from "../../core/layer.js";
+import { MutationHandler } from "../../core/mutation-handler.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 { schemaLookupHint } from "../../utils/error-hints.js";
+import { SchemaValidator } from "../../validators/schema-validator.js";
+import { CLIError, ErrorCategory, findSimilar, formatValidOptions } 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."),
+  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(),
+  sourceRepoRemote: z.string().optional(),
+  sourceRepoCommit: z.string().optional().describe("Full 40-character Git commit SHA."),
+  rootPath: rootPathSchema
+};
+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 (!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"
+      ]);
+    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'
+      ]);
+    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
+    });
+  });
+}
+const modelAddTool = {
+  name: "model_add",
+  description: "Add a new element to a layer, validated against its spec schema.",
+  inputSchema,
+  handler: modelAddHandler
+};
+export {
+  modelAddHandler,
+  modelAddTool
+};
+//# sourceMappingURL=model-add.js.map

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

@@ -0,0 +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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",
+  "names": []
+}

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

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { DependencyTracker, TraceDirection } from "../../core/dependency-tracker.js";
+import { MutationHandler } from "../../core/mutation-handler.js";
+import { ReferenceRegistry } from "../../core/reference-registry.js";
+import { findElementLayer } from "../../utils/element-utils.js";
+import { CLIError, ErrorCategory, getErrorMessage } from "../../utils/errors.js";
+import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  id: z.string().describe("Element ID or path to delete."),
+  cascade: z.boolean().optional().describe("Also delete elements that depend on this one."),
+  force: z.boolean().optional().describe("Skip the dependency check and delete only this element, even if others depend on it."),
+  dryRun: z.boolean().optional().describe("Preview what would be deleted without making changes."),
+  rootPath: rootPathSchema
+};
+async function modelDeleteHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), layerName = await findElementLayer(model, args.id);
+    if (!layerName)
+      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "model_search" to find similar elements'
+      ]);
+    const element = (await model.getLayer(layerName)).getElement(args.id);
+    if (!element)
+      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "model_search" to find similar elements'
+      ]);
+    const registry = new ReferenceRegistry();
+    for (const l of model.layers.values())
+      for (const el of l.listElements())
+        registry.registerElement(el);
+    const dependents = new DependencyTracker(registry, model).traceDependencies(args.id, TraceDirection.DOWN, null);
+    if (dependents.length > 0 && !args.cascade && !args.force)
+      throw new CLIError("Element has dependencies", ErrorCategory.USER, [
+        "Use cascade=true to remove all dependent elements",
+        "Use dryRun=true with cascade=true to preview what would be deleted",
+        "Or use force=true to remove only this element (dependencies will reference a non-existent element)"
+      ]);
+    const elementsToRemove = args.cascade ? [args.id, ...dependents] : [args.id];
+    if (args.dryRun)
+      return jsonResult({
+        status: "dry-run",
+        id: args.id,
+        layer: layerName,
+        elementsToRemove
+      });
+    let deletedCount = 0;
+    const skippedDependents = [], cascadeDeleted = [];
+    if (args.cascade && dependents.length > 0)
+      for (const depId of [...dependents].reverse()) {
+        const depLayerName = await findElementLayer(model, depId);
+        if (!depLayerName) {
+          console.error(`[mcp] model_delete: cascade dependent "${depId}" not found, skipping`), skippedDependents.push(depId);
+          continue;
+        }
+        const depElement = (await model.getLayer(depLayerName)).getElement(depId);
+        if (!depElement) {
+          console.error(`[mcp] model_delete: cascade dependent "${depId}" not found, skipping`), skippedDependents.push(depId);
+          continue;
+        }
+        const depHandler = new MutationHandler(model, depId, depLayerName);
+        try {
+          await depHandler.executeDelete(depElement);
+        } catch (error) {
+          throw new CLIError(`Failed to delete dependent element "${depId}": ${getErrorMessage(error)}`, ErrorCategory.SYSTEM, [
+            `${cascadeDeleted.length} dependent element(s) were deleted before the error`,
+            'Use "model_validate" to check the model for broken references',
+            `"${args.id}" was not deleted \u2014 you can retry the operation once dependents are resolved`
+          ], {
+            operation: "model_delete (cascade)",
+            relatedElements: cascadeDeleted,
+            partialProgress: { completed: cascadeDeleted.length, total: dependents.length }
+          });
+        }
+        cascadeDeleted.push(depId), deletedCount++;
+      }
+    const mutationHandler = new MutationHandler(model, args.id, layerName);
+    await mutationHandler.executeDelete(element);
+    const activeChangeset = await mutationHandler.getStagingManager().getActive(), staged = !!(activeChangeset && activeChangeset.status === "staged");
+    return staged && await reloadModel(args.rootPath), jsonResult({
+      status: staged ? "staged" : "deleted",
+      changeset: staged ? activeChangeset.name : void 0,
+      id: args.id,
+      layer: layerName,
+      cascadedDeletes: deletedCount,
+      ...skippedDependents.length > 0 ? { skippedDependents } : {}
+    });
+  });
+}
+const modelDeleteTool = {
+  name: "model_delete",
+  description: "Delete an element, optionally cascading to elements that depend on it.",
+  inputSchema,
+  handler: modelDeleteHandler
+};
+export {
+  modelDeleteHandler,
+  modelDeleteTool
+};
+//# sourceMappingURL=model-delete.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-delete.ts"],
+  "sourcesContent": ["/**\n * model_delete \u2014 delete an element (optionally cascading to dependents).\n * Mirrors `dr delete`, but since an MCP session has no interactive confirmation\n * channel, the caller must pass `force` or `cascade` explicitly when dependents\n * exist rather than being prompted; operates through the shared MutationHandler.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { DependencyTracker, TraceDirection } from \"../../core/dependency-tracker.js\";\nimport { MutationHandler } from \"../../core/mutation-handler.js\";\nimport { ReferenceRegistry } from \"../../core/reference-registry.js\";\nimport { findElementLayer } from \"../../utils/element-utils.js\";\nimport { CLIError, ErrorCategory, getErrorMessage } from \"../../utils/errors.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 delete.\"),\n  cascade: z.boolean().optional().describe(\"Also delete elements that depend on this one.\"),\n  force: z.boolean().optional().describe(\"Skip the dependency check and delete only this element, even if others depend on it.\"),\n  dryRun: z.boolean().optional().describe(\"Preview what would be deleted without making changes.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelDeleteArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function modelDeleteHandler(args: ModelDeleteArgs): Promise<CallToolResult> {\n  return runTool(async () => {\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 (!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    // Cascade is scoped to cross-layer references only, matching `dr delete`. This is\n    // narrower than \"model_trace\", which also follows intra-layer relationships.yaml\n    // edges \u2014 a dependent found by model_trace may not be included in a cascade delete.\n    const registry = new ReferenceRegistry();\n    for (const l of model.layers.values()) {\n      for (const el of l.listElements()) {\n        registry.registerElement(el);\n      }\n    }\n    const tracker = new DependencyTracker(registry, model);\n    const dependents = tracker.traceDependencies(args.id, TraceDirection.DOWN, null);\n\n    if (dependents.length > 0 && !args.cascade && !args.force) {\n      throw new CLIError(\"Element has dependencies\", ErrorCategory.USER, [\n        \"Use cascade=true to remove all dependent elements\",\n        \"Use dryRun=true with cascade=true to preview what would be deleted\",\n        \"Or use force=true to remove only this element (dependencies will reference a non-existent element)\",\n      ]);\n    }\n\n    const elementsToRemove = args.cascade ? [args.id, ...dependents] : [args.id];\n\n    if (args.dryRun) {\n      return jsonResult({\n        status: \"dry-run\",\n        id: args.id,\n        layer: layerName,\n        elementsToRemove,\n      });\n    }\n\n    let deletedCount = 0;\n    const skippedDependents: string[] = [];\n    const cascadeDeleted: string[] = [];\n    if (args.cascade && dependents.length > 0) {\n      for (const depId of [...dependents].reverse()) {\n        const depLayerName = await findElementLayer(model, depId);\n        if (!depLayerName) {\n          console.error(`[mcp] model_delete: cascade dependent \"${depId}\" not found, skipping`);\n          skippedDependents.push(depId);\n          continue;\n        }\n\n        const depLayer = (await model.getLayer(depLayerName))!;\n        const depElement = depLayer.getElement(depId);\n        if (!depElement) {\n          console.error(`[mcp] model_delete: cascade dependent \"${depId}\" not found, skipping`);\n          skippedDependents.push(depId);\n          continue;\n        }\n\n        const depHandler = new MutationHandler(model, depId, depLayerName);\n        try {\n          await depHandler.executeDelete(depElement);\n        } catch (error) {\n          throw new CLIError(\n            `Failed to delete dependent element \"${depId}\": ${getErrorMessage(error)}`,\n            ErrorCategory.SYSTEM,\n            [\n              `${cascadeDeleted.length} dependent element(s) were deleted before the error`,\n              'Use \"model_validate\" to check the model for broken references',\n              `\"${args.id}\" was not deleted \u2014 you can retry the operation once dependents are resolved`,\n            ],\n            {\n              operation: \"model_delete (cascade)\",\n              relatedElements: cascadeDeleted,\n              partialProgress: { completed: cascadeDeleted.length, total: dependents.length },\n            }\n          );\n        }\n        cascadeDeleted.push(depId);\n        deletedCount++;\n      }\n    }\n\n    const mutationHandler = new MutationHandler(model, args.id, layerName);\n    await mutationHandler.executeDelete(element);\n\n    const stagingManager = mutationHandler.getStagingManager();\n    const activeChangeset = await stagingManager.getActive();\n    const staged = !!(activeChangeset && activeChangeset.status === \"staged\");\n    // The cached model's merged relationships still hold the rows the delete just staged for\n    // removal; reload so later reads (model_validate, model_export) see the plan.\n    if (staged) await reloadModel(args.rootPath);\n\n    return jsonResult({\n      status: staged ? \"staged\" : \"deleted\",\n      changeset: staged ? activeChangeset!.name : undefined,\n      id: args.id,\n      layer: layerName,\n      cascadedDeletes: deletedCount,\n      ...(skippedDependents.length > 0 ? { skippedDependents } : {}),\n    });\n  });\n}\n\nexport const modelDeleteTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_delete\",\n  description: \"Delete an element, optionally cascading to elements that depend on it.\",\n  inputSchema,\n  handler: modelDeleteHandler,\n};\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { ArchiMateExporter, ExportManager, GraphMLExporter, JsonSchemaExporter, MarkdownExporter, MermaidMarkdownExporter, OpenAPIExporter, PlantUMLExporter } from "../../export/index.js";
+import { Validator } from "../../validators/validator.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  format: z.string().describe("Export format: archimate, openapi, json-schema, plantuml, graphml, markdown, or mermaid-markdown."),
+  layers: z.array(z.string()).optional().describe("Restrict export to these layers (must be supported by the chosen format)."),
+  includeSources: z.boolean().optional().describe("Include source_reference provenance in the export, where supported."),
+  rootPath: rootPathSchema
+};
+function buildExportManager() {
+  const manager = new ExportManager();
+  return manager.register("archimate", new ArchiMateExporter(), {
+    description: "ArchiMate 3.2 XML format",
+    mimeType: "application/xml"
+  }), manager.register("openapi", new OpenAPIExporter(), {
+    description: "OpenAPI 3.0 specification",
+    mimeType: "application/json"
+  }), manager.register("json-schema", new JsonSchemaExporter(), {
+    description: "JSON Schema Draft 7",
+    mimeType: "application/json"
+  }), manager.register("jsonschema", new JsonSchemaExporter(), {
+    description: "JSON Schema Draft 7",
+    mimeType: "application/json"
+  }), manager.register("plantuml", new PlantUMLExporter(), {
+    description: "PlantUML diagram format",
+    mimeType: "text/plain"
+  }), manager.register("graphml", new GraphMLExporter(), {
+    description: "GraphML graph format",
+    mimeType: "application/xml"
+  }), manager.register("markdown", new MarkdownExporter(), {
+    description: "Markdown documentation",
+    mimeType: "text/markdown"
+  }), manager.register("mermaid-markdown", new MermaidMarkdownExporter(), {
+    description: "Markdown with Mermaid diagrams and formatted tables",
+    mimeType: "text/markdown"
+  }), manager;
+}
+const SEMANTIC_FORMATS = /* @__PURE__ */ new Set(["openapi", "archimate", "jsonschema", "json-schema"]);
+async function modelExportHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = buildExportManager(), format = args.format.toLowerCase();
+    if (!manager.hasFormat(format)) {
+      const available = manager.getAllFormats().map((f) => f.format);
+      throw new CLIError(`Unknown export format: ${args.format}`, ErrorCategory.USER, [
+        `Available formats: ${available.join(", ")}`
+      ]);
+    }
+    const warnings = [];
+    if (SEMANTIC_FORMATS.has(format)) {
+      const validationResult = await new Validator().validateModel(model);
+      validationResult.isValid() || warnings.push(`Model has ${validationResult.errors.length} validation error(s). Export output may be incomplete or incorrect.`);
+    }
+    const content = await manager.export(model, format, {
+      layers: args.layers,
+      includeSources: args.includeSources
+    });
+    return jsonResult({ format, warnings, content });
+  });
+}
+const modelExportTool = {
+  name: "model_export",
+  description: "Export the architecture model to ArchiMate, OpenAPI, JSON Schema, PlantUML, GraphML, Markdown, or Markdown with Mermaid diagrams.",
+  inputSchema,
+  handler: modelExportHandler
+};
+export {
+  modelExportHandler,
+  modelExportTool
+};
+//# sourceMappingURL=model-export.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-export.ts"],
+  "sourcesContent": ["/**\n * model_export \u2014 export the model to a documentation/interchange format.\n * Mirrors `dr export`, reusing the shared ExportManager and exporters.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport {\n  ArchiMateExporter,\n  ExportManager,\n  GraphMLExporter,\n  JsonSchemaExporter,\n  MarkdownExporter,\n  MermaidMarkdownExporter,\n  OpenAPIExporter,\n  PlantUMLExporter,\n} from \"../../export/index.js\";\nimport { Validator } from \"../../validators/validator.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  format: z\n    .string()\n    .describe(\"Export format: archimate, openapi, json-schema, plantuml, graphml, markdown, or mermaid-markdown.\"),\n  layers: z.array(z.string()).optional().describe(\"Restrict export to these layers (must be supported by the chosen format).\"),\n  includeSources: z.boolean().optional().describe(\"Include source_reference provenance in the export, where supported.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelExportArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nfunction buildExportManager(): ExportManager {\n  const manager = new ExportManager();\n  manager.register(\"archimate\", new ArchiMateExporter(), {\n    description: \"ArchiMate 3.2 XML format\",\n    mimeType: \"application/xml\",\n  });\n  manager.register(\"openapi\", new OpenAPIExporter(), {\n    description: \"OpenAPI 3.0 specification\",\n    mimeType: \"application/json\",\n  });\n  manager.register(\"json-schema\", new JsonSchemaExporter(), {\n    description: \"JSON Schema Draft 7\",\n    mimeType: \"application/json\",\n  });\n  manager.register(\"jsonschema\", new JsonSchemaExporter(), {\n    description: \"JSON Schema Draft 7\",\n    mimeType: \"application/json\",\n  });\n  manager.register(\"plantuml\", new PlantUMLExporter(), {\n    description: \"PlantUML diagram format\",\n    mimeType: \"text/plain\",\n  });\n  manager.register(\"graphml\", new GraphMLExporter(), {\n    description: \"GraphML graph format\",\n    mimeType: \"application/xml\",\n  });\n  manager.register(\"markdown\", new MarkdownExporter(), {\n    description: \"Markdown documentation\",\n    mimeType: \"text/markdown\",\n  });\n  manager.register(\"mermaid-markdown\", new MermaidMarkdownExporter(), {\n    description: \"Markdown with Mermaid diagrams and formatted tables\",\n    mimeType: \"text/markdown\",\n  });\n  return manager;\n}\n\nconst SEMANTIC_FORMATS = new Set([\"openapi\", \"archimate\", \"jsonschema\", \"json-schema\"]);\n\nexport async function modelExportHandler(args: ModelExportArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    // Unlike \"model_validate\", this exports the base model as-is and does not project\n    // the active changeset onto it \u2014 matching `dr export`. A staged-but-uncommitted\n    // change will not appear in the export output.\n    const model = await loadModel(args.rootPath);\n    const manager = buildExportManager();\n    const format = args.format.toLowerCase();\n\n    if (!manager.hasFormat(format)) {\n      const available = manager.getAllFormats().map((f) => f.format);\n      throw new CLIError(`Unknown export format: ${args.format}`, ErrorCategory.USER, [\n        `Available formats: ${available.join(\", \")}`,\n      ]);\n    }\n\n    const warnings: string[] = [];\n    if (SEMANTIC_FORMATS.has(format)) {\n      const validator = new Validator();\n      const validationResult = await validator.validateModel(model);\n      if (!validationResult.isValid()) {\n        warnings.push(\n          `Model has ${validationResult.errors.length} validation error(s). Export output may be incomplete or incorrect.`\n        );\n      }\n    }\n\n    const content = await manager.export(model, format, {\n      layers: args.layers,\n      includeSources: args.includeSources,\n    });\n\n    return jsonResult({ format, warnings, content });\n  });\n}\n\nexport const modelExportTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_export\",\n  description:\n    \"Export the architecture model to ArchiMate, OpenAPI, JSON Schema, PlantUML, GraphML, Markdown, or Markdown with Mermaid diagrams.\",\n  inputSchema,\n  handler: modelExportHandler,\n};\n"],
+  "mappings": "AAKA,SAAS,SAAS;AAElB,SACE,mBACA,eACA,iBACA,oBACA,kBACA,yBACA,iBACA,wBACK;AACP,SAAS,iBAAiB;AAC1B,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,QAAQ,EACL,OAAM,EACN,SAAS,mGAAmG;EAC/G,QAAQ,EAAE,MAAM,EAAE,OAAM,CAAE,EAAE,SAAQ,EAAG,SAAS,2EAA2E;EAC3H,gBAAgB,EAAE,QAAO,EAAG,SAAQ,EAAG,SAAS,qEAAqE;EACrH,UAAU;;AAKZ,SAAS,qBAAkB;AACzB,QAAM,UAAU,IAAI,cAAa;AACjC,iBAAQ,SAAS,aAAa,IAAI,kBAAiB,GAAI;IACrD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,WAAW,IAAI,gBAAe,GAAI;IACjD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,eAAe,IAAI,mBAAkB,GAAI;IACxD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,cAAc,IAAI,mBAAkB,GAAI;IACvD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,YAAY,IAAI,iBAAgB,GAAI;IACnD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,WAAW,IAAI,gBAAe,GAAI;IACjD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,YAAY,IAAI,iBAAgB,GAAI;IACnD,aAAa;IACb,UAAU;GACX,GACD,QAAQ,SAAS,oBAAoB,IAAI,wBAAuB,GAAI;IAClE,aAAa;IACb,UAAU;GACX,GACM;AACT;AAEA,MAAM,mBAAmB,oBAAI,IAAI,CAAC,WAAW,aAAa,cAAc,aAAa,CAAC;AAEtF,eAAsB,mBAAmB,MAAqB;AAC5D,SAAO,QAAQ,YAAW;AAIxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,UAAU,mBAAkB,GAC5B,SAAS,KAAK,OAAO,YAAW;AAEtC,QAAI,CAAC,QAAQ,UAAU,MAAM,GAAG;AAC9B,YAAM,YAAY,QAAQ,cAAa,EAAG,IAAI,CAAC,MAAM,EAAE,MAAM;AAC7D,YAAM,IAAI,SAAS,0BAA0B,KAAK,MAAM,IAAI,cAAc,MAAM;QAC9E,sBAAsB,UAAU,KAAK,IAAI,CAAC;OAC3C;IACH;AAEA,UAAM,WAAqB,CAAA;AAC3B,QAAI,iBAAiB,IAAI,MAAM,GAAG;AAEhC,YAAM,mBAAmB,MADP,IAAI,UAAS,EACU,cAAc,KAAK;AAC5D,MAAK,iBAAiB,QAAO,KAC3B,SAAS,KACP,aAAa,iBAAiB,OAAO,MAAM,qEAAqE;IAGtH;AAEA,UAAM,UAAU,MAAM,QAAQ,OAAO,OAAO,QAAQ;MAClD,QAAQ,KAAK;MACb,gBAAgB,KAAK;KACtB;AAED,WAAO,WAAW,EAAE,QAAQ,UAAU,QAAO,CAAE;EACjD,CAAC;AACH;AAEO,MAAM,kBAAyD;EACpE,MAAM;EACN,aACE;EACF;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  layer: z.string().optional().describe("Show details for a single layer instead of the whole-model summary."),
+  rootPath: rootPathSchema
+};
+async function modelInfoHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manifest = model.manifest, modelSummary = {
+      name: manifest.name,
+      version: manifest.version,
+      specVersion: manifest.specVersion,
+      description: manifest.description,
+      author: manifest.author,
+      created: manifest.created,
+      modified: manifest.modified
+    };
+    if (args.layer) {
+      const layer = await model.getLayer(args.layer);
+      if (!layer)
+        throw new CLIError(`Layer ${args.layer} not found`, ErrorCategory.NOT_FOUND, [
+          'Use "model_info" (without a layer) to see all available layers'
+        ]);
+      const elements = layer.listElements(), elementsByType = {};
+      for (const element of elements)
+        elementsByType[element.type] = (elementsByType[element.type] || 0) + 1;
+      return jsonResult({
+        model: modelSummary,
+        layer: { name: args.layer, elementCount: elements.length, elementsByType }
+      });
+    }
+    const layerNames = model.getLayerNames(), layers = [];
+    for (const layerName of layerNames) {
+      const layer = await model.getLayer(layerName);
+      layer && layers.push({ name: layerName, elementCount: layer.listElements().length });
+    }
+    return jsonResult({ model: modelSummary, layers });
+  });
+}
+const modelInfoTool = {
+  name: "model_info",
+  description: "Get model metadata and a summary of layers (or a single layer's element type breakdown).",
+  inputSchema,
+  handler: modelInfoHandler
+};
+export {
+  modelInfoHandler,
+  modelInfoTool
+};
+//# sourceMappingURL=model-info.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-info.ts"],
+  "sourcesContent": ["/**\n * model_info \u2014 model or single-layer summary information. Mirrors `dr info`.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  layer: z.string().optional().describe(\"Show details for a single layer instead of the whole-model summary.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelInfoArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function modelInfoHandler(args: ModelInfoArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manifest = model.manifest;\n\n    const modelSummary = {\n      name: manifest.name,\n      version: manifest.version,\n      specVersion: manifest.specVersion,\n      description: manifest.description,\n      author: manifest.author,\n      created: manifest.created,\n      modified: manifest.modified,\n    };\n\n    if (args.layer) {\n      const layer = await model.getLayer(args.layer);\n      if (!layer) {\n        throw new CLIError(`Layer ${args.layer} not found`, ErrorCategory.NOT_FOUND, [\n          'Use \"model_info\" (without a layer) to see all available layers',\n        ]);\n      }\n\n      const elements = layer.listElements();\n      const elementsByType: Record<string, number> = {};\n      for (const element of elements) {\n        elementsByType[element.type] = (elementsByType[element.type] || 0) + 1;\n      }\n\n      return jsonResult({\n        model: modelSummary,\n        layer: { name: args.layer, elementCount: elements.length, elementsByType },\n      });\n    }\n\n    const layerNames = model.getLayerNames();\n    const layers: Array<{ name: string; elementCount: number }> = [];\n    for (const layerName of layerNames) {\n      const layer = await model.getLayer(layerName);\n      if (!layer) continue;\n      layers.push({ name: layerName, elementCount: layer.listElements().length });\n    }\n\n    return jsonResult({ model: modelSummary, layers });\n  });\n}\n\nexport const modelInfoTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_info\",\n  description: \"Get model metadata and a summary of layers (or a single layer's element type breakdown).\",\n  inputSchema,\n  handler: modelInfoHandler,\n};\n"],
+  "mappings": "AAIA,SAAS,SAAS;AAElB,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,OAAO,EAAE,OAAM,EAAG,SAAQ,EAAG,SAAS,qEAAqE;EAC3G,UAAU;;AAKZ,eAAsB,iBAAiB,MAAmB;AACxD,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,WAAW,MAAM,UAEjB,eAAe;MACnB,MAAM,SAAS;MACf,SAAS,SAAS;MAClB,aAAa,SAAS;MACtB,aAAa,SAAS;MACtB,QAAQ,SAAS;MACjB,SAAS,SAAS;MAClB,UAAU,SAAS;;AAGrB,QAAI,KAAK,OAAO;AACd,YAAM,QAAQ,MAAM,MAAM,SAAS,KAAK,KAAK;AAC7C,UAAI,CAAC;AACH,cAAM,IAAI,SAAS,SAAS,KAAK,KAAK,cAAc,cAAc,WAAW;UAC3E;SACD;AAGH,YAAM,WAAW,MAAM,aAAY,GAC7B,iBAAyC,CAAA;AAC/C,iBAAW,WAAW;AACpB,uBAAe,QAAQ,IAAI,KAAK,eAAe,QAAQ,IAAI,KAAK,KAAK;AAGvE,aAAO,WAAW;QAChB,OAAO;QACP,OAAO,EAAE,MAAM,KAAK,OAAO,cAAc,SAAS,QAAQ,eAAc;OACzE;IACH;AAEA,UAAM,aAAa,MAAM,cAAa,GAChC,SAAwD,CAAA;AAC9D,eAAW,aAAa,YAAY;AAClC,YAAM,QAAQ,MAAM,MAAM,SAAS,SAAS;AAC5C,MAAK,SACL,OAAO,KAAK,EAAE,MAAM,WAAW,cAAc,MAAM,aAAY,EAAG,OAAM,CAAE;IAC5E;AAEA,WAAO,WAAW,EAAE,OAAO,cAAc,OAAM,CAAE;EACnD,CAAC;AACH;AAEO,MAAM,gBAAuD;EAClE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { CANONICAL_LAYER_NAMES } from "../../core/layers.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  layer: z.string().optional().describe("Canonical layer name to list (e.g. 'api', 'data-model'). Omit to list across all layers."),
+  type: z.string().optional().describe("Restrict results to a single element type."),
+  rootPath: rootPathSchema
+};
+async function modelListHandler(args) {
+  return runTool(async () => {
+    if (args.layer) {
+      const layer = await (await loadModel(args.rootPath)).getLayer(args.layer);
+      if (!layer)
+        throw new CLIError(`Layer ${args.layer} not found`, ErrorCategory.NOT_FOUND, [
+          'Use "model_info" to see all available layers'
+        ]);
+      let elements = layer.listElements();
+      return args.type && (elements = elements.filter((e) => e.type === args.type)), jsonResult({
+        layer: args.layer,
+        count: elements.length,
+        elements: elements.map((e) => e.toJSON())
+      });
+    }
+    const model = await loadModel(args.rootPath), layers = [];
+    for (const layerName of CANONICAL_LAYER_NAMES) {
+      const layer = await model.getLayer(layerName);
+      if (!layer)
+        continue;
+      let elements = layer.listElements();
+      args.type && (elements = elements.filter((e) => e.type === args.type)), elements.length > 0 && layers.push({
+        layer: layerName,
+        count: elements.length,
+        elements: elements.map((e) => e.toJSON())
+      });
+    }
+    return jsonResult({
+      layers,
+      totalElements: layers.reduce((sum, l) => sum + l.count, 0)
+    });
+  });
+}
+const modelListTool = {
+  name: "model_list",
+  description: "List elements in the architecture model, optionally scoped to a layer and/or element type.",
+  inputSchema,
+  handler: modelListHandler
+};
+export {
+  modelListHandler,
+  modelListTool
+};
+//# sourceMappingURL=model-list.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-list.ts"],
+  "sourcesContent": ["/**\n * model_list \u2014 list elements in the architecture model, optionally scoped to\n * a single layer and/or element type. Mirrors `dr list`.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { CANONICAL_LAYER_NAMES } from \"../../core/layers.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  layer: z\n    .string()\n    .optional()\n    .describe(\"Canonical layer name to list (e.g. 'api', 'data-model'). Omit to list across all layers.\"),\n  type: z.string().optional().describe(\"Restrict results to a single element type.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelListArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function modelListHandler(args: ModelListArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (args.layer) {\n      const model = await loadModel(args.rootPath);\n      const layer = await model.getLayer(args.layer);\n      if (!layer) {\n        throw new CLIError(`Layer ${args.layer} not found`, ErrorCategory.NOT_FOUND, [\n          'Use \"model_info\" to see all available layers',\n        ]);\n      }\n\n      let elements = layer.listElements();\n      if (args.type) {\n        elements = elements.filter((e) => e.type === args.type);\n      }\n\n      return jsonResult({\n        layer: args.layer,\n        count: elements.length,\n        elements: elements.map((e) => e.toJSON()),\n      });\n    }\n\n    const model = await loadModel(args.rootPath);\n    const layers: Array<{ layer: string; count: number; elements: unknown[] }> = [];\n\n    for (const layerName of CANONICAL_LAYER_NAMES) {\n      const layer = await model.getLayer(layerName);\n      if (!layer) continue;\n\n      let elements = layer.listElements();\n      if (args.type) {\n        elements = elements.filter((e) => e.type === args.type);\n      }\n\n      if (elements.length > 0) {\n        layers.push({\n          layer: layerName,\n          count: elements.length,\n          elements: elements.map((e) => e.toJSON()),\n        });\n      }\n    }\n\n    return jsonResult({\n      layers,\n      totalElements: layers.reduce((sum, l) => sum + l.count, 0),\n    });\n  });\n}\n\nexport const modelListTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_list\",\n  description:\n    \"List elements in the architecture model, optionally scoped to a layer and/or element type.\",\n  inputSchema,\n  handler: modelListHandler,\n};\n"],
+  "mappings": "AAKA,SAAS,SAAS;AAElB,SAAS,6BAA6B;AACtC,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,OAAO,EACJ,OAAM,EACN,SAAQ,EACR,SAAS,0FAA0F;EACtG,MAAM,EAAE,OAAM,EAAG,SAAQ,EAAG,SAAS,4CAA4C;EACjF,UAAU;;AAKZ,eAAsB,iBAAiB,MAAmB;AACxD,SAAO,QAAQ,YAAW;AACxB,QAAI,KAAK,OAAO;AAEd,YAAM,QAAQ,OADA,MAAM,UAAU,KAAK,QAAQ,GACjB,SAAS,KAAK,KAAK;AAC7C,UAAI,CAAC;AACH,cAAM,IAAI,SAAS,SAAS,KAAK,KAAK,cAAc,cAAc,WAAW;UAC3E;SACD;AAGH,UAAI,WAAW,MAAM,aAAY;AACjC,aAAI,KAAK,SACP,WAAW,SAAS,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,IAGjD,WAAW;QAChB,OAAO,KAAK;QACZ,OAAO,SAAS;QAChB,UAAU,SAAS,IAAI,CAAC,MAAM,EAAE,OAAM,CAAE;OACzC;IACH;AAEA,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,SAAuE,CAAA;AAE7E,eAAW,aAAa,uBAAuB;AAC7C,YAAM,QAAQ,MAAM,MAAM,SAAS,SAAS;AAC5C,UAAI,CAAC;AAAO;AAEZ,UAAI,WAAW,MAAM,aAAY;AACjC,MAAI,KAAK,SACP,WAAW,SAAS,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,IAGpD,SAAS,SAAS,KACpB,OAAO,KAAK;QACV,OAAO;QACP,OAAO,SAAS;QAChB,UAAU,SAAS,IAAI,CAAC,MAAM,EAAE,OAAM,CAAE;OACzC;IAEL;AAEA,WAAO,WAAW;MAChB;MACA,eAAe,OAAO,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,OAAO,CAAC;KAC1D;EACH,CAAC;AACH;AAEO,MAAM,gBAAuD;EAClE,MAAM;EACN,aACE;EACF;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,34 @@
+import { jsonResult, reloadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  rootPath: rootPathSchema
+};
+async function modelReloadHandler(args) {
+  return runTool(async () => {
+    const model = await reloadModel(args.rootPath), layers = [];
+    for (const layerName of model.getLayerNames()) {
+      const layer = await model.getLayer(layerName);
+      layer && layers.push({ name: layerName, elementCount: layer.listElements().length });
+    }
+    return jsonResult({
+      status: "reloaded",
+      model: {
+        name: model.manifest.name,
+        version: model.manifest.version,
+        modified: model.manifest.modified
+      },
+      layers,
+      totalElements: layers.reduce((sum, layer) => sum + layer.elementCount, 0)
+    });
+  });
+}
+const modelReloadTool = {
+  name: "model_reload",
+  description: "Force a full reload of the architecture model from disk and report a summary of its current state.",
+  inputSchema,
+  handler: modelReloadHandler
+};
+export {
+  modelReloadHandler,
+  modelReloadTool
+};
+//# sourceMappingURL=model-reload.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-reload.ts"],
+  "sourcesContent": ["/**\n * model_reload \u2014 force a full, non-lazy reload of the architecture model from\n * disk and report a summary of what was read.\n *\n * `loadModel()` (shared.ts) loads the model once per rootPath and holds it in\n * memory for reuse across tool calls, the same way the REST/visualization server\n * holds a long-lived `this.model` field (see `setupFileWatcher()` in\n * `cli/src/server/server.ts`). That cache can go stale after edits made outside\n * this MCP session (e.g. the CLI or another process editing files on disk), so\n * this tool exists to force a fresh read and refresh the cache \u2014 the MCP\n * equivalent of that server's file-watcher-triggered reload.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { jsonResult, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  rootPath: rootPathSchema,\n};\n\nexport type ModelReloadArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function modelReloadHandler(args: ModelReloadArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await reloadModel(args.rootPath);\n\n    const layers: Array<{ name: string; elementCount: number }> = [];\n    for (const layerName of model.getLayerNames()) {\n      const layer = await model.getLayer(layerName);\n      if (!layer) continue;\n      layers.push({ name: layerName, elementCount: layer.listElements().length });\n    }\n\n    return jsonResult({\n      status: \"reloaded\",\n      model: {\n        name: model.manifest.name,\n        version: model.manifest.version,\n        modified: model.manifest.modified,\n      },\n      layers,\n      totalElements: layers.reduce((sum, layer) => sum + layer.elementCount, 0),\n    });\n  });\n}\n\nexport const modelReloadTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_reload\",\n  description: \"Force a full reload of the architecture model from disk and report a summary of its current state.\",\n  inputSchema,\n  handler: modelReloadHandler,\n};\n"],
+  "mappings": "AAeA,SAAS,YAAY,aAAa,gBAAgB,eAAuC;AAEzF,MAAM,cAAc;EAClB,UAAU;;AAKZ,eAAsB,mBAAmB,MAAqB;AAC5D,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,YAAY,KAAK,QAAQ,GAEvC,SAAwD,CAAA;AAC9D,eAAW,aAAa,MAAM,cAAa,GAAI;AAC7C,YAAM,QAAQ,MAAM,MAAM,SAAS,SAAS;AAC5C,MAAK,SACL,OAAO,KAAK,EAAE,MAAM,WAAW,cAAc,MAAM,aAAY,EAAG,OAAM,CAAE;IAC5E;AAEA,WAAO,WAAW;MAChB,QAAQ;MACR,OAAO;QACL,MAAM,MAAM,SAAS;QACrB,SAAS,MAAM,SAAS;QACxB,UAAU,MAAM,SAAS;;MAE3B;MACA,eAAe,OAAO,OAAO,CAAC,KAAK,UAAU,MAAM,MAAM,cAAc,CAAC;KACzE;EACH,CAAC;AACH;AAEO,MAAM,kBAAyD;EACpE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}