@documentation-robotics/cli 0.1.13 → 0.2.0

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 { SchemaValidator } from \"../../validators/schema-validator.js\";\nimport { CLIError, ErrorCategory, findSimilar, formatValidOptions } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, 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);\n\n    const model = await loadModel(args.rootPath);\n\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          `Use \"model_info\" with layer \"${args.layer}\" and the spec resource for \"${args.type}\" to see the required attributes`,\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\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, 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 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, 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\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": []
+}

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

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { getAllLayerIds, isValidLayer } from "../../generated/layer-registry.js";
+import { NODE_TYPES } from "../../generated/node-types.js";
+import { CLIError, ErrorCategory, findSimilar, formatValidOptions } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  query: z.string().optional().describe("Text to match against element ID and name (case-insensitive substring). Ignored when sourceFile is set."),
+  layer: z.string().optional().describe("Restrict search to a single layer."),
+  type: z.string().optional().describe("Restrict search to a single element type."),
+  sourceFile: z.string().optional().describe("Find elements whose source_reference points at this file path."),
+  rootPath: rootPathSchema
+};
+function normalizePath(filePath) {
+  return filePath.replace(/^\.\//, "").replace(/\\/g, "/");
+}
+function matchesSourceFile(element, sourceFilePath) {
+  const sourceRef = element.getSourceReference();
+  if (!sourceRef)
+    return !1;
+  const normalizedQuery = normalizePath(sourceFilePath);
+  return (sourceRef.locations ?? []).some((loc) => normalizePath(loc.file) === normalizedQuery);
+}
+async function modelSearchHandler(args) {
+  return runTool(async () => {
+    if (!args.query && !args.sourceFile && !args.layer && !args.type)
+      throw new CLIError("At least one of query, sourceFile, layer, or type must be provided", ErrorCategory.USER, ['Use "model_list" to list all elements without filtering']);
+    if (args.layer && !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.type) {
+      const candidateTypes = args.layer ? Array.from(NODE_TYPES.values()).filter((t) => t.layer === args.layer) : Array.from(NODE_TYPES.values());
+      if (!candidateTypes.some((t) => t.type === args.type)) {
+        const validTypeNames = Array.from(new Set(candidateTypes.map((t) => t.type))).sort(), similar = findSimilar(args.type, validTypeNames, 3), suggestions = [
+          args.layer ? `Valid types for ${args.layer}: ${formatValidOptions(validTypeNames)}` : `Valid types: ${formatValidOptions(validTypeNames)}`
+        ];
+        throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Unknown element type "${args.type}"${args.layer ? ` for layer "${args.layer}"` : ""}`, ErrorCategory.USER, suggestions);
+      }
+    }
+    const model = await loadModel(args.rootPath), isSourceFileSearch = !!args.sourceFile, queryLower = (args.query ?? "").toLowerCase(), results = [];
+    for (const layerName of model.getLayerNames()) {
+      if (args.layer && layerName !== args.layer)
+        continue;
+      const layerObj = await model.getLayer(layerName);
+      if (layerObj)
+        for (const element of layerObj.listElements()) {
+          if (args.type && element.type !== args.type)
+            continue;
+          if (isSourceFileSearch) {
+            if (!matchesSourceFile(element, args.sourceFile))
+              continue;
+          } else {
+            const idMatch = (element.path || element.id).toLowerCase().includes(queryLower), nameMatch = element.name.toLowerCase().includes(queryLower);
+            if (!idMatch && !nameMatch)
+              continue;
+          }
+          let sourceFile, sourceSymbol;
+          const sourceRef = element.getSourceReference();
+          sourceRef?.locations && sourceRef.locations.length > 0 && (sourceFile = sourceRef.locations[0].file, sourceSymbol = sourceRef.locations[0].symbol), results.push({
+            layer: layerName,
+            id: element.path || element.id,
+            type: element.type,
+            name: element.name,
+            description: element.description,
+            sourceFile,
+            sourceSymbol
+          });
+        }
+    }
+    return jsonResult({
+      query: args.query ?? "",
+      sourceFile: args.sourceFile,
+      count: results.length,
+      results
+    });
+  });
+}
+const modelSearchTool = {
+  name: "model_search",
+  description: "Search for elements across the model by name/ID substring or by source file reference.",
+  inputSchema,
+  handler: modelSearchHandler
+};
+export {
+  modelSearchHandler,
+  modelSearchTool
+};
+//# sourceMappingURL=model-search.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-search.ts"],
+  "sourcesContent": ["/**\n * model_search \u2014 search for elements across the model by name/ID substring or\n * source file reference. Mirrors `dr search`.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport type { Element } from \"../../core/element.js\";\nimport { getAllLayerIds, isValidLayer } from \"../../generated/layer-registry.js\";\nimport { NODE_TYPES } from \"../../generated/node-types.js\";\nimport { CLIError, ErrorCategory, findSimilar, formatValidOptions } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  query: z\n    .string()\n    .optional()\n    .describe(\"Text to match against element ID and name (case-insensitive substring). Ignored when sourceFile is set.\"),\n  layer: z.string().optional().describe(\"Restrict search to a single layer.\"),\n  type: z.string().optional().describe(\"Restrict search to a single element type.\"),\n  sourceFile: z.string().optional().describe(\"Find elements whose source_reference points at this file path.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelSearchArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nfunction normalizePath(filePath: string): string {\n  return filePath.replace(/^\\.\\//, \"\").replace(/\\\\/g, \"/\");\n}\n\nfunction matchesSourceFile(element: Element, sourceFilePath: string): boolean {\n  const sourceRef = element.getSourceReference();\n  if (!sourceRef) return false;\n\n  const normalizedQuery = normalizePath(sourceFilePath);\n  return (sourceRef.locations ?? []).some((loc) => normalizePath(loc.file) === normalizedQuery);\n}\n\nexport async function modelSearchHandler(args: ModelSearchArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (!args.query && !args.sourceFile && !args.layer && !args.type) {\n      throw new CLIError(\n        \"At least one of query, sourceFile, layer, or type must be provided\",\n        ErrorCategory.USER,\n        ['Use \"model_list\" to list all elements without filtering']\n      );\n    }\n\n    if (args.layer && !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 (args.type) {\n      const candidateTypes = args.layer\n        ? Array.from(NODE_TYPES.values()).filter((t) => t.layer === args.layer)\n        : Array.from(NODE_TYPES.values());\n      const isKnownType = candidateTypes.some((t) => t.type === args.type);\n      if (!isKnownType) {\n        const validTypeNames = Array.from(new Set(candidateTypes.map((t) => t.type))).sort();\n        const similar = findSimilar(args.type, validTypeNames, 3);\n        const suggestions: string[] = [\n          args.layer\n            ? `Valid types for ${args.layer}: ${formatValidOptions(validTypeNames)}`\n            : `Valid types: ${formatValidOptions(validTypeNames)}`,\n        ];\n        if (similar.length > 0) suggestions.unshift(`Did you mean: ${similar.join(\" or \")}?`);\n        throw new CLIError(\n          `Unknown element type \"${args.type}\"${args.layer ? ` for layer \"${args.layer}\"` : \"\"}`,\n          ErrorCategory.USER,\n          suggestions\n        );\n      }\n    }\n\n    const model = await loadModel(args.rootPath);\n    const isSourceFileSearch = !!args.sourceFile;\n    const queryLower = (args.query ?? \"\").toLowerCase();\n\n    const results: Array<{\n      layer: string;\n      id: string;\n      type: string;\n      name: string;\n      description?: string;\n      sourceFile?: string;\n      sourceSymbol?: string;\n    }> = [];\n\n    for (const layerName of model.getLayerNames()) {\n      if (args.layer && layerName !== args.layer) continue;\n\n      const layerObj = await model.getLayer(layerName);\n      if (!layerObj) continue;\n\n      for (const element of layerObj.listElements()) {\n        if (args.type && element.type !== args.type) continue;\n\n        if (isSourceFileSearch) {\n          if (!matchesSourceFile(element, args.sourceFile!)) continue;\n        } else {\n          const displayId = element.path || element.id;\n          const idMatch = displayId.toLowerCase().includes(queryLower);\n          const nameMatch = element.name.toLowerCase().includes(queryLower);\n          if (!idMatch && !nameMatch) continue;\n        }\n\n        let sourceFile: string | undefined;\n        let sourceSymbol: string | undefined;\n        const sourceRef = element.getSourceReference();\n        if (sourceRef?.locations && sourceRef.locations.length > 0) {\n          sourceFile = sourceRef.locations[0].file;\n          sourceSymbol = sourceRef.locations[0].symbol;\n        }\n\n        results.push({\n          layer: layerName,\n          id: element.path || element.id,\n          type: element.type,\n          name: element.name,\n          description: element.description,\n          sourceFile,\n          sourceSymbol,\n        });\n      }\n    }\n\n    return jsonResult({\n      query: args.query ?? \"\",\n      sourceFile: args.sourceFile,\n      count: results.length,\n      results,\n    });\n  });\n}\n\nexport const modelSearchTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_search\",\n  description: \"Search for elements across the model by name/ID substring or by source file reference.\",\n  inputSchema,\n  handler: modelSearchHandler,\n};\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { findElementLayer } from "../../utils/element-utils.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  id: z.string().describe("Element ID or path (e.g. 'api.operation.create-order')."),
+  rootPath: rootPathSchema
+};
+async function modelShowHandler(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',
+        'Use "model_list" to list all elements in a layer'
+      ]);
+    const layer = await model.getLayer(layerName), element = layer?.getElement(args.id);
+    if (!layer || !element)
+      throw new CLIError(`Element ${args.id} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "model_search" to find similar elements',
+        'Use "model_list" to list all elements in a layer'
+      ]);
+    const elementId = element.path || element.id, { outgoing, incoming } = model.relationships.getForElement(elementId);
+    return jsonResult({
+      layer: layerName,
+      element: element.toJSON(),
+      relationships: { outgoing, incoming }
+    });
+  });
+}
+const modelShowTool = {
+  name: "model_show",
+  description: "Show a single element's full details, attributes, and relationships.",
+  inputSchema,
+  handler: modelShowHandler
+};
+export {
+  modelShowHandler,
+  modelShowTool
+};
+//# sourceMappingURL=model-show.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/model-show.ts"],
+  "sourcesContent": ["/**\n * model_show \u2014 show a single element with its relationships. Mirrors `dr show`.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { findElementLayer } from \"../../utils/element-utils.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  id: z.string().describe(\"Element ID or path (e.g. 'api.operation.create-order').\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ModelShowArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function modelShowHandler(args: ModelShowArgs): 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        'Use \"model_list\" to list all elements in a layer',\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        'Use \"model_list\" to list all elements in a layer',\n      ]);\n    }\n\n    const elementId = element.path || element.id;\n    const { outgoing, incoming } = model.relationships.getForElement(elementId);\n\n    return jsonResult({\n      layer: layerName,\n      element: element.toJSON(),\n      relationships: { outgoing, incoming },\n    });\n  });\n}\n\nexport const modelShowTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"model_show\",\n  description: \"Show a single element's full details, attributes, and relationships.\",\n  inputSchema,\n  handler: modelShowHandler,\n};\n"],
+  "mappings": "AAIA,SAAS,SAAS;AAElB,SAAS,wBAAwB;AACjC,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,IAAI,EAAE,OAAM,EAAG,SAAS,yDAAyD;EACjF,UAAU;;AAKZ,eAAsB,iBAAiB,MAAmB;AACxD,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,YAAY,MAAM,iBAAiB,OAAO,KAAK,EAAE;AACvD,QAAI,CAAC;AACH,YAAM,IAAI,SAAS,WAAW,KAAK,EAAE,cAAc,cAAc,WAAW;QAC1E;QACA;OACD;AAGH,UAAM,QAAQ,MAAM,MAAM,SAAS,SAAS,GACtC,UAAU,OAAO,WAAW,KAAK,EAAE;AACzC,QAAI,CAAC,SAAS,CAAC;AACb,YAAM,IAAI,SAAS,WAAW,KAAK,EAAE,cAAc,cAAc,WAAW;QAC1E;QACA;OACD;AAGH,UAAM,YAAY,QAAQ,QAAQ,QAAQ,IACpC,EAAE,UAAU,SAAQ,IAAK,MAAM,cAAc,cAAc,SAAS;AAE1E,WAAO,WAAW;MAChB,OAAO;MACP,SAAS,QAAQ,OAAM;MACvB,eAAe,EAAE,UAAU,SAAQ;KACpC;EACH,CAAC;AACH;AAEO,MAAM,gBAAuD;EAClE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,22 @@
+import { StatsCollector } from "../../core/stats-collector.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  rootPath: rootPathSchema
+};
+async function modelStatsHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), stats = await new StatsCollector(model).collect();
+    return jsonResult(stats);
+  });
+}
+const modelStatsTool = {
+  name: "model_stats",
+  description: "Get aggregate statistics about the architecture model: element counts, relationships, coverage, and orphans.",
+  inputSchema,
+  handler: modelStatsHandler
+};
+export {
+  modelStatsHandler,
+  modelStatsTool
+};
+//# sourceMappingURL=model-stats.js.map