@documentation-robotics/cli 0.1.13 → 0.3.0

package/dist/commands/relationship.js

@@ -3,12 +3,17 @@ import { Model } from "../core/model.js";
 import { StagingAreaManager } from "../core/staging-area.js";
 import { findElementLayer } from "../utils/element-utils.js";
 import { isValidLayerName } from "../core/layers.js";
-import { CLIError, ErrorCategory, handleError, getErrorMessage } from "../utils/errors.js";
+import { CLIError, ErrorCategory, handleError, handleSuccess, handleInfo, getErrorMessage } from "../utils/errors.js";
 import { getValidRelationships, getValidPredicatesForSource, getValidDestinationsForSourceAndPredicate } from "../generated/relationship-index.js";
 import { normalizeNodeType } from "../generated/node-types.js";
 import { ModelReportOrchestrator } from "../reports/model-report-orchestrator.js";
 import { emitLog, SeverityNumber } from "../telemetry/index.js";
+import { elementIdentifiers } from "../core/relationships.js";
 import { RelationshipCatalog } from "../core/relationship-catalog.js";
+import { collectKnownIdentifiers, findDanglingRelationships } from "../core/relationship-prune.js";
+import { isJson } from "../utils/globals.js";
+import { ChangesetGraph } from "../core/changeset-graph.js";
+import { liveRelationshipsBetween, planRelationshipAdd, stageRelationshipDeletes } from "../core/relationship-staging.js";
 function constructSpecNodeId(element, elementId) {
   const layerId = element.layer_id, type = element.type;
   if (typeof layerId != "string" || !layerId)
@@ -39,6 +44,13 @@ function getRelationshipConstraints(sourceSpecNodeId, predicate, destSpecNodeId)
   };
 }
 async function addRelationshipHandler(model, source, target, predicate, properties, preResolved) {
+  return await addRelationship(model, source, target, predicate, properties, preResolved) !== "duplicate";
+}
+async function activeStagedChangeset(manager) {
+  const active = await manager.getActive();
+  return active && active.status === "staged" ? active : null;
+}
+async function addRelationship(model, source, target, predicate, properties, preResolved) {
   let resolvedSourceLayerName = preResolved?.source?.layerName, resolvedSourceElement = preResolved?.source?.element, resolvedTargetLayerName = preResolved?.target?.layerName, resolvedTargetElement = preResolved?.target?.element;
   if (!resolvedSourceLayerName && (resolvedSourceLayerName = await findElementLayer(model, source), !resolvedSourceLayerName))
     throw new CLIError(`Source element ${source} not found`, ErrorCategory.USER);
@@ -68,9 +80,19 @@ async function addRelationshipHandler(model, source, target, predicate, properti
     if (relType && !relType.semantics.reflexivity && source === target)
       throw new CLIError(`Invalid relationship: predicate "${predicate}" does not allow reflexive relationships (${source})`, ErrorCategory.USER);
   }
-  if (model.relationships.find(source, target, predicate).length > 0)
-    return console.warn(ansis.yellow(`Warning: Relationship ${source} --[${predicate}]--> ${target} already exists. Skipping.`)), !1;
-  const stagingManager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await stagingManager.getActiveId(), relData = {
+  const stagingManager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await stagingManager.getActiveId(), activeChangeset = activeChangesetId ? await activeStagedChangeset(stagingManager) : null;
+  if (activeChangeset) {
+    const graph = await ChangesetGraph.build(model, activeChangeset), plan = planRelationshipAdd(graph, activeChangeset, { source, predicate, target });
+    if (plan.action === "duplicate")
+      return "duplicate";
+    if (plan.action === "restore") {
+      for (const key of plan.keys)
+        await stagingManager.unstage(activeChangeset.id, key);
+      return "restored";
+    }
+  } else if (model.relationships.find(source, target, predicate).length > 0)
+    return "duplicate";
+  const relData = {
     source,
     target,
     predicate,
@@ -109,15 +131,35 @@ async function addRelationshipHandler(model, source, target, predicate, properti
       });
     }
   }
-  return !0;
+  return activeChangesetId ? "staged" : "added";
+}
+async function findRelationshipsByEndpoints(model, source, target, predicate) {
+  const sourceIds = new Set(elementIdentifiers(model.getElementById(source) ?? {}, source)), targetIds = new Set(elementIdentifiers(model.getElementById(target) ?? {}, target));
+  return model.relationships.getAll().filter((rel) => sourceIds.has(rel.source) && targetIds.has(rel.target) && (!predicate || rel.predicate === predicate));
 }
-async function deleteRelationshipHandler(model, source, target, predicate, preResolved) {
+function noMatchingRelationshipHints(surface, source, inChangeset) {
+  return surface === "mcp" ? [
+    `Use "model_show" on ${source} to see its relationships`,
+    inChangeset ? 'Use "changeset_brief" to see what this changeset already stages' : 'Use "model_search" to check the source and target element IDs'
+  ] : [
+    `Use "dr relationship list ${source}" to see the relationships recorded for ${source}`,
+    inChangeset ? 'Use "dr changeset staged" to see what the active changeset already stages' : 'Use "dr relationship prune --dry-run" to list rows whose endpoints no longer resolve'
+  ];
+}
+async function deleteRelationshipHandler(model, source, target, predicate, preResolved, surface = "cli") {
+  const changesetManager = new StagingAreaManager(model.rootPath, model), changeset = await changesetManager.getActiveId() ? await activeStagedChangeset(changesetManager) : null;
+  if (changeset) {
+    const graph = await ChangesetGraph.build(model, changeset), matches = liveRelationshipsBetween(graph, source, target, predicate);
+    if (matches.length === 0)
+      throw new CLIError("No matching relationships found", ErrorCategory.USER, noMatchingRelationshipHints(surface, source, !0));
+    const staged = await stageRelationshipDeletes(changesetManager, graph, changeset, matches);
+    return { deletedCount: staged.length, staged };
+  }
   let resolvedSourceLayerName = preResolved?.sourceLayerName;
-  if (!resolvedSourceLayerName && (resolvedSourceLayerName = await findElementLayer(model, source), !resolvedSourceLayerName))
-    throw new CLIError(`Source element ${source} not found`, ErrorCategory.USER);
+  resolvedSourceLayerName || (resolvedSourceLayerName = await findElementLayer(model, source));
   let resolvedToDelete = preResolved?.toDelete;
-  if (resolvedToDelete || (resolvedToDelete = model.relationships.find(source, target, predicate)), resolvedToDelete.length === 0)
-    throw new CLIError("No matching relationships found", ErrorCategory.USER);
+  if (resolvedToDelete || (resolvedToDelete = await findRelationshipsByEndpoints(model, source, target, predicate)), resolvedToDelete.length === 0)
+    throw new CLIError("No matching relationships found", ErrorCategory.USER, noMatchingRelationshipHints(surface, source, !1));
   const stagingManager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await stagingManager.getActiveId();
   if (activeChangesetId)
     for (const rel of resolvedToDelete) {
@@ -137,7 +179,9 @@ async function deleteRelationshipHandler(model, source, target, predicate, preRe
       });
     }
   else {
-    model.relationships.delete(source, target, predicate), await model.saveRelationships(), await model.saveManifest();
+    for (const rel of resolvedToDelete)
+      model.relationships.delete(rel.source, rel.target, rel.predicate);
+    await model.saveRelationships(), await model.saveManifest();
     try {
       const orchestrator = new ModelReportOrchestrator(model, model.rootPath), affectedLayers = /* @__PURE__ */ new Set();
       for (const rel of resolvedToDelete) {
@@ -161,15 +205,115 @@ async function deleteRelationshipHandler(model, source, target, predicate, preRe
   }
   return { deletedCount: resolvedToDelete.length };
 }
-function relationshipCommands(program) {
-  program.command("add <source> <target>").description("Add a relationship between elements (intra-layer or cross-layer)").requiredOption("--predicate <predicate>", "Relationship predicate (e.g., depends-on, realizes, exposes)").option("--properties <json>", "Relationship properties (JSON)").addHelpText("after", `
+async function pruneRelationshipsCommand(options) {
+  const format = options.format ?? "text";
+  if (format !== "text" && format !== "json")
+    throw new CLIError(`Invalid format: ${format}`, ErrorCategory.USER, [
+      "Use --format text or --format json"
+    ]);
+  const jsonOutput = format === "json" || isJson(), layers = options.layers?.length ? options.layers : void 0;
+  if (layers) {
+    const invalid = layers.filter((l) => !isValidLayerName(l));
+    if (invalid.length > 0)
+      throw new CLIError(`Invalid layer name(s): ${invalid.join(", ")}`, ErrorCategory.USER, ['Use canonical layer names, e.g. "api", "data-model", "data-store"']);
+  }
+  const model = await Model.load(options.model || process.cwd()), elements = [];
+  for (const layerName of model.getLayerNames()) {
+    const layer = await model.getLayer(layerName);
+    layer && elements.push(...layer.listElements());
+  }
+  const known = collectKnownIdentifiers(elements), analysis = findDanglingRelationships(model.relationships.getAll(), known, { layers }), stagingManager = new StagingAreaManager(model.rootPath, model), activeChangeset = await stagingManager.getActive(), staging = !!activeChangeset && activeChangeset.status === "staged", result = {
+    scanned: analysis.scanned,
+    dangling: analysis.dangling.length,
+    removed: 0,
+    dryRun: !!options.dryRun,
+    staged: !1,
+    ...staging ? { changeset: activeChangeset.name } : {},
+    ...layers ? { layers } : {},
+    relationships: analysis.dangling.map(({ relationship: rel, unresolved }) => ({
+      source: rel.source,
+      predicate: rel.predicate,
+      target: rel.target,
+      layer: rel.layer,
+      ...rel.targetLayer ? { targetLayer: rel.targetLayer } : {},
+      unresolved
+    }))
+  };
+  if (!options.dryRun && analysis.dangling.length > 0) {
+    if (staging) {
+      for (const { relationship: rel } of analysis.dangling)
+        await stagingManager.stage(activeChangeset.id, {
+          type: "relationship-delete",
+          elementId: `${rel.source}::${rel.predicate}::${rel.target}`,
+          layerName: rel.layer,
+          before: {
+            source: rel.source,
+            target: rel.target,
+            predicate: rel.predicate,
+            layer: rel.layer,
+            ...rel.targetLayer ? { targetLayer: rel.targetLayer } : {},
+            ...rel.properties ? { properties: rel.properties } : {}
+          }
+        });
+      result.staged = !0;
+    } else {
+      const danglingRows = new Set(analysis.dangling.map((d) => d.relationship));
+      model.relationships.retain((rel) => !danglingRows.has(rel)), await model.saveRelationships({ preserveHeader: !0 }), await model.saveManifest();
+      try {
+        const orchestrator = new ModelReportOrchestrator(model, model.rootPath), affectedLayers = /* @__PURE__ */ new Set();
+        for (const { relationship: rel } of analysis.dangling)
+          for (const name of [rel.layer, rel.targetLayer])
+            if (name && isValidLayerName(name))
+              for (const affected of orchestrator.computeAffectedLayers(name))
+                affectedLayers.add(affected);
+        await orchestrator.regenerate(affectedLayers);
+      } catch (error) {
+        emitLog(SeverityNumber.WARN, "Failed to regenerate layer reports after relationship prune", {
+          "relationship.pruned": analysis.dangling.length,
+          "error.message": getErrorMessage(error)
+        });
+      }
+    }
+    result.removed = analysis.dangling.length;
+  }
+  if (jsonOutput)
+    return console.log(JSON.stringify({ status: "ok", ...result }, null, 2)), result;
+  const scope = layers ? ` in layer(s) ${layers.join(", ")}` : "";
+  handleInfo(`Scanned ${result.scanned} relationship(s)${scope}: ${result.dangling} dangling`);
+  for (const row of result.relationships) {
+    const side = row.unresolved === "both" ? "source and target not found" : `${row.unresolved} not found`;
+    handleInfo(`  - ${ansis.yellow(row.source)} --[${ansis.magenta(row.predicate)}]--> ${ansis.yellow(row.target)} ${ansis.dim(`(${side})`)}`);
+  }
+  return result.dangling === 0 ? handleSuccess("No dangling relationships found", {
+    scanned: result.scanned,
+    dangling: 0,
+    removed: 0
+  }) : result.dryRun ? handleSuccess(`Dry run: would remove ${result.dangling} dangling relationship(s)`, {
+    scanned: result.scanned,
+    dangling: result.dangling,
+    removed: 0,
+    dryRun: !0
+  }) : result.staged ? handleSuccess(`Staged removal of ${result.removed} dangling relationship(s) to ${ansis.bold(result.changeset)}`, {
+    scanned: result.scanned,
+    dangling: result.dangling,
+    removed: result.removed,
+    changesetStatus: "staged",
+    changeset: result.changeset
+  }) : handleSuccess(`Removed ${result.removed} dangling relationship(s)`, {
+    scanned: result.scanned,
+    dangling: result.dangling,
+    removed: result.removed
+  }), result;
+}
+function relationshipCommands(program, rootProgram) {
+  program.command("add <source> <target>").description("Add a relationship between elements (intra-layer or cross-layer)").option("--model <path>", "Path to model root (contains model/manifest.yaml)").requiredOption("--predicate <predicate>", "Relationship predicate (e.g., depends-on, realizes, exposes)").option("--properties <json>", "Relationship properties (JSON)").addHelpText("after", `
 Examples:
   $ dr relationship add motivation.goal.goal-a motivation.goal.goal-b --predicate aggregates
   $ dr relationship add api.operation.create-order application.service.order-service --predicate exposes
   $ dr relationship add business.businessprocess.checkout application.applicationprocess.checkout --predicate aggregates
   $ dr relationship add element-1 element-2 --predicate realizes --properties '{"strength":"high"}'`).action(async (source, target, options) => {
     try {
-      const model = await Model.load(), sourceLayerName = await findElementLayer(model, source);
+      const model = await Model.load(options.model), sourceLayerName = await findElementLayer(model, source);
       if (!sourceLayerName)
         throw new CLIError(`Source element ${source} not found`, ErrorCategory.USER);
       const sourceLayer = await model.getLayer(sourceLayerName);
@@ -195,111 +339,171 @@ Examples:
         } catch {
           throw new CLIError("Invalid JSON in --properties", ErrorCategory.USER);
         }
-      const activeChangesetId = await new StagingAreaManager(model.rootPath, model).getActiveId();
-      if (!await addRelationshipHandler(model, source, target, options.predicate, properties, {
+      const activeChangesetId = await new StagingAreaManager(model.rootPath, model).getActiveId(), outcome = await addRelationship(model, source, target, options.predicate, properties, {
         source: { element: sourceElement, layerName: sourceLayerName },
         target: { element: targetElement, layerName: targetLayerName }
-      }))
+      });
+      if (outcome === "duplicate") {
+        handleSuccess(`Relationship ${source} --[${options.predicate}]--> ${target} already exists` + (activeChangesetId ? " (in the model or the active changeset); nothing staged" : ""), {
+          source,
+          target,
+          predicate: options.predicate,
+          layer: sourceLayerName,
+          duplicate: !0,
+          ...activeChangesetId ? { changesetStatus: "unchanged" } : {}
+        }, { verbose: options.verbose });
         return;
-      let message = `\u2713 Added relationship: ${ansis.bold(source)} ${options.predicate} ${ansis.bold(target)}`;
-      constraints && (message += ansis.dim(` (${constraints.cardinality}, ${constraints.strength} strength)`)), activeChangesetId && (message += ansis.dim(" [staged]")), console.log(ansis.green(message));
+      }
+      if (outcome === "restored") {
+        handleSuccess(`Restored relationship: ${ansis.bold(source)} ${options.predicate} ${ansis.bold(target)}` + ansis.dim(" [the active changeset's staged deletion of it was unstaged]"), {
+          source,
+          target,
+          predicate: options.predicate,
+          layer: sourceLayerName,
+          restored: !0,
+          changesetStatus: "unstaged"
+        }, { verbose: options.verbose });
+        return;
+      }
+      let message = `Added relationship: ${ansis.bold(source)} ${options.predicate} ${ansis.bold(target)}`;
+      const details = {
+        source,
+        target,
+        predicate: options.predicate,
+        layer: sourceLayerName
+      };
+      constraints && (message += ansis.dim(` (${constraints.cardinality}, ${constraints.strength} strength)`), details.cardinality = constraints.cardinality, details.strength = constraints.strength), activeChangesetId && (message += ansis.dim(" [staged]"), details.changesetStatus = "staged"), handleSuccess(message, details, { verbose: options.verbose });
     } catch (error) {
       handleError(error);
     }
-  }), program.command("delete <source> <target>").description("Delete a relationship").option("--predicate <predicate>", "Specific predicate to delete (optional, delete all if not specified)").option("--force", "Skip confirmation prompt").addHelpText("after", `
+  }), program.command("delete <source> <target>").description("Delete a relationship").option("--model <path>", "Path to model root (contains model/manifest.yaml)").option("--predicate <predicate>", "Specific predicate to delete (optional, delete all if not specified)").option("--force", "Skip confirmation prompt").addHelpText("after", `
 Examples:
   $ dr relationship delete element-1 element-2 --predicate depends-on
   $ dr relationship delete element-1 element-2 --force`).action(async (source, target, options) => {
     try {
-      const model = await Model.load(), sourceLayerName = await findElementLayer(model, source);
-      if (!sourceLayerName)
-        throw new CLIError(`Source element ${source} not found`, ErrorCategory.USER);
-      const toDelete = model.relationships.find(source, target, options.predicate);
+      const model = await Model.load(options.model), activeForDelete = await activeStagedChangeset(new StagingAreaManager(model.rootPath, model)), toDelete = activeForDelete ? liveRelationshipsBetween(await ChangesetGraph.build(model, activeForDelete), source, target, options.predicate) : await findRelationshipsByEndpoints(model, source, target, options.predicate);
       if (toDelete.length === 0)
-        throw new CLIError("No matching relationships found", ErrorCategory.USER);
-      const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+        throw new CLIError("No matching relationships found", ErrorCategory.USER, [
+          `Use "dr relationship list ${source}" to see the relationships recorded for ${source}`,
+          'Use "dr relationship prune --dry-run" to list rows whose endpoints no longer resolve'
+        ]);
+      const sourceLayerName = await findElementLayer(model, source) ?? toDelete[0].layer, isInteractive = process.stdin.isTTY && process.stdout.isTTY;
       if (!options.force && isInteractive) {
         const { confirm } = await import("@clack/prompts");
         if (!await confirm({
           message: `Delete ${toDelete.length} relationship(s)? This cannot be undone.`,
           initialValue: !1
         })) {
-          console.log(ansis.dim("Cancelled"));
+          handleSuccess("Deletion cancelled", {
+            source,
+            target,
+            status: "cancelled"
+          });
           return;
         }
       }
       const activeChangesetId = await new StagingAreaManager(model.rootPath, model).getActiveId(), result = await deleteRelationshipHandler(model, source, target, options.predicate, {
         sourceLayerName,
-        toDelete
-      }), stagedSuffix = activeChangesetId ? " [staged]" : "";
-      console.log(ansis.green(`\u2713 Deleted ${result.deletedCount} relationship(s) from ${ansis.bold(source)} to ${ansis.bold(target)}${stagedSuffix}`));
+        // In a changeset the handler re-reads the projected graph itself.
+        toDelete: activeForDelete ? void 0 : toDelete
+      }), stagedSuffix = activeChangesetId ? " [staged]" : "", deleteDetails = {
+        source,
+        target,
+        layer: sourceLayerName,
+        deletedCount: result.deletedCount,
+        ...result.staged ? { relationships: result.staged } : {}
+      };
+      options.predicate && (deleteDetails.predicate = options.predicate), activeChangesetId && (deleteDetails.changesetStatus = "staged"), handleSuccess(`Deleted ${result.deletedCount} relationship(s) from ${ansis.bold(source)} to ${ansis.bold(target)}${stagedSuffix}`, deleteDetails, { verbose: options.verbose });
+    } catch (error) {
+      handleError(error);
+    }
+  }), program.command("prune").description("Remove relationship rows whose source or target no longer resolves to an element").option("--model <path>", "Path to model root (contains model/manifest.yaml)").option("--dry-run", "List the rows that would be removed without writing").option("--layers <layers...>", "Only scan rows whose source or target layer is one of these canonical layer names").option("--format <format>", "Output format: text, json", "text").addHelpText("after", `
+A row is dangling when its source or target matches neither the UUID id nor the
+dotted path of any current element. Kept rows keep their order and the file's
+header comment is preserved. Inside an active changeset the removals are staged
+as relationship deletions instead of being written to relationships.yaml.
+
+Examples:
+  $ dr relationship prune --dry-run
+  $ dr relationship prune
+  $ dr relationship prune --layers api application --format json`).action(async (options) => {
+    try {
+      await pruneRelationshipsCommand({
+        model: options.model,
+        dryRun: !!options.dryRun,
+        layers: options.layers,
+        format: options.format
+      });
     } catch (error) {
       handleError(error);
     }
-  }), program.command("list <id>").description("List relationships for an element").option("--direction <dir>", "Filter by direction (incoming/outgoing/all)", "all").option("--json", "Output as JSON").addHelpText("after", `
+  }), program.command("list <id>").description("List relationships for an element").option("--model <path>", "Path to model root (contains model/manifest.yaml)").option("--direction <dir>", "Filter by direction (incoming/outgoing/all)", "all").option("--json", "Output as JSON").addHelpText("after", `
 Examples:
   $ dr relationship list api-endpoint-create-customer
   $ dr relationship list business-service-order --direction outgoing
   $ dr relationship list element-1 --json`).action(async (id, options) => {
     try {
-      const model = await Model.load();
+      const model = await Model.load(options.model);
       if (!await findElementLayer(model, id))
         throw new CLIError(`Element ${id} not found`, ErrorCategory.USER);
       const { outgoing, incoming } = model.relationships.getForElement(id);
       let relationships = [];
-      if ((options.direction === "outgoing" || options.direction === "all") && relationships.push(...outgoing), (options.direction === "incoming" || options.direction === "all") && relationships.push(...incoming), options.json) {
+      if ((options.direction === "outgoing" || options.direction === "all") && relationships.push(...outgoing), (options.direction === "incoming" || options.direction === "all") && relationships.push(...incoming), options.json ?? rootProgram?.opts().json) {
         console.log(JSON.stringify(relationships, null, 2));
         return;
       }
       if (relationships.length === 0) {
-        console.log(ansis.yellow(`No ${options.direction} relationships for ${id}`));
+        handleInfo(ansis.yellow(`No ${options.direction} relationships for ${id}`));
         return;
       }
-      console.log(""), console.log(ansis.bold(`${options.direction === "all" ? "" : options.direction + " "}relationships for ${ansis.cyan(id)}:`)), console.log(ansis.dim("\u2500".repeat(80)));
+      handleInfo(""), handleInfo(ansis.bold(`${options.direction === "all" ? "" : options.direction + " "}relationships for ${ansis.cyan(id)}:`)), handleInfo(ansis.dim("\u2500".repeat(80)));
       for (const rel of relationships) {
         const isOutgoing = rel.source === id, direction = isOutgoing ? "\u2192" : "\u2190", otherElement = isOutgoing ? rel.target : rel.source, crossLayer = rel.targetLayer && rel.targetLayer !== rel.layer ? ansis.dim(` [${rel.layer} \u2192 ${rel.targetLayer}]`) : "";
-        if (console.log(`  ${direction} ${ansis.magenta(rel.predicate)}: ${ansis.yellow(otherElement)}${crossLayer}`), rel.properties) {
+        if (handleInfo(`  ${direction} ${ansis.magenta(rel.predicate)}: ${ansis.yellow(otherElement)}${crossLayer}`), rel.properties) {
           const propStr = Object.entries(rel.properties).map(([k, v]) => `${k}=${v}`).join(", ");
-          console.log(`    ${ansis.dim(propStr)}`);
+          handleInfo(`    ${ansis.dim(propStr)}`);
         }
       }
-      console.log(ansis.dim("\u2500".repeat(80))), console.log(ansis.dim(`Total: ${relationships.length} relationship(s)`)), console.log("");
+      handleInfo(ansis.dim("\u2500".repeat(80))), handleInfo(ansis.dim(`Total: ${relationships.length} relationship(s)`)), handleInfo("");
     } catch (error) {
       handleError(error);
     }
-  }), program.command("show <source> <target>").description("Show relationship details").addHelpText("after", `
+  }), program.command("show <source> <target>").description("Show relationship details").option("--model <path>", "Path to model root (contains model/manifest.yaml)").addHelpText("after", `
 Examples:
   $ dr relationship show api-endpoint-create-customer business-service-customer-mgmt
-  $ dr relationship show application-component-api motivation-goal-sales-efficiency`).action(async (source, target) => {
+  $ dr relationship show application-component-api motivation-goal-sales-efficiency`).action(async (source, target, options) => {
     try {
-      const model = await Model.load();
+      const model = await Model.load(options.model);
       if (!await findElementLayer(model, source))
         throw new CLIError(`Source element ${source} not found`, ErrorCategory.USER);
       const relationships = model.relationships.find(source, target);
       if (relationships.length === 0)
         throw new CLIError(`No relationships from ${source} to ${target}`, ErrorCategory.USER);
-      console.log(""), console.log(ansis.bold(`Relationship${relationships.length > 1 ? "s" : ""} from ${ansis.cyan(source)} to ${ansis.yellow(target)}:`)), console.log(ansis.dim("\u2500".repeat(60)));
+      handleInfo(""), handleInfo(ansis.bold(`Relationship${relationships.length > 1 ? "s" : ""} from ${ansis.cyan(source)} to ${ansis.yellow(target)}:`)), handleInfo(ansis.dim("\u2500".repeat(60)));
       for (let i = 0; i < relationships.length; i++) {
         const rel = relationships[i];
-        if (i > 0 && console.log(""), console.log(`Predicate: ${ansis.magenta(rel.predicate)}`), console.log(`Layer:     ${ansis.cyan(rel.layer)}`), rel.targetLayer && rel.targetLayer !== rel.layer && console.log(`Target Layer: ${ansis.cyan(rel.targetLayer)}`), rel.properties && Object.keys(rel.properties).length > 0) {
-          console.log("Properties:");
+        if (i > 0 && handleInfo(""), handleInfo(`Predicate: ${ansis.magenta(rel.predicate)}`), handleInfo(`Layer:     ${ansis.cyan(rel.layer)}`), rel.targetLayer && rel.targetLayer !== rel.layer && handleInfo(`Target Layer: ${ansis.cyan(rel.targetLayer)}`), rel.properties && Object.keys(rel.properties).length > 0) {
+          handleInfo("Properties:");
           for (const [key, value] of Object.entries(rel.properties)) {
             const displayValue = typeof value == "string" ? value : JSON.stringify(value, null, 2);
-            console.log(`  ${ansis.cyan(key)}: ${displayValue}`);
+            handleInfo(`  ${ansis.cyan(key)}: ${displayValue}`);
           }
         } else
-          console.log("Properties: none");
+          handleInfo("Properties: none");
       }
-      console.log("");
+      handleInfo("");
     } catch (error) {
       handleError(error);
     }
   });
 }
 export {
+  addRelationship,
   addRelationshipHandler,
   deleteRelationshipHandler,
+  findRelationshipsByEndpoints,
   getRelationshipConstraints,
+  pruneRelationshipsCommand,
   relationshipCommands,
   validateRelationshipCombination
 };