@documentation-robotics/cli 0.1.0 → 0.1.5

package/dist/commands/changeset.js

@@ -1,37 +1,63 @@
 import ansis from "ansis";
 import { Model } from "../core/model.js";
-import { ChangesetManager } from "../core/changeset.js";
-import { ActiveChangesetContext } from "../core/active-changeset.js";
+import { StagingAreaManager } from "../core/staging-area.js";
+import { ChangesetExporter } from "../core/changeset-exporter.js";
+import { StagedChangesetStorage } from "../core/staged-changeset-storage.js";
+import { ValidationFormatter } from "../validators/validation-formatter.js";
 import * as prompts from "@clack/prompts";
+import path from "path";
+import { isTelemetryEnabled, startSpan, endSpan, startActiveSpan } from "../telemetry/index.js";
+import { getErrorMessage } from "../utils/errors.js";
+import { findElementLayer } from "../utils/element-utils.js";
+function generateImportedChangesetId() {
+  return `imported-${Date.now()}`;
+}
 async function changesetCreateCommand(name, options) {
+  const span = isTelemetryEnabled ? startSpan("changeset.create", {
+    "changeset.name": name,
+    "changeset.hasDescription": !!options.description
+  }) : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new ChangesetManager(model.rootPath);
-    await manager.load(name) && (console.error(ansis.red(`Error: Changeset '${name}' already exists`)), process.exit(1));
+    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model);
+    await manager.load(name) && (console.error(ansis.red(`Error: Changeset '${name}' already exists`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset already exists" }), endSpan(span), process.exit(1));
     let description = options.description;
     if (!description) {
-      const result = await prompts.text({
-        message: "Changeset description (optional)"
-      });
-      typeof result == "string" && (description = result);
+      const isInteractive = process.stdin.isTTY;
+      if (isTelemetryEnabled && span && span.setAttribute("cli.interactive", isInteractive), isInteractive) {
+        const result = await prompts.text({
+          message: "Changeset description (optional)"
+        });
+        typeof result == "string" && (description = result);
+      }
+    }
+    const changeset = await manager.create(name, description || void 0), previouslyActive = await manager.getActiveId();
+    if (previouslyActive) {
+      const previous = await manager.load(previouslyActive);
+      console.log(ansis.yellow(`  Deactivating changeset: ${ansis.bold(previous?.name ?? previouslyActive)}`));
     }
-    const changeset = await manager.create(name, description || void 0);
-    console.log(ansis.green(`\u2713 Created changeset: ${ansis.bold(name)}`)), changeset.description && console.log(ansis.dim(`  ${changeset.description}`)), console.log(ansis.dim(`  Path: .dr/changesets/${name.toLowerCase().replace(/\s+/g, "-")}.json`)), console.log();
+    await manager.setActive(changeset.id), isTelemetryEnabled && span && (span.setAttribute("changeset.id", changeset.id), span.setStatus({ code: 0 })), console.log(ansis.green(`\u2713 Created and activated changeset: ${ansis.bold(name)}`)), changeset.description && console.log(ansis.dim(`  ${changeset.description}`)), console.log(ansis.dim(`  Path: documentation-robotics/changesets/${changeset.id}/`)), console.log();
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
 async function changesetListCommand() {
+  const span = isTelemetryEnabled ? startSpan("changeset.list") : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), changesets = await new ChangesetManager(model.rootPath).list();
-    if (changesets.length === 0) {
-      console.log(ansis.yellow("No changesets found")), console.log();
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), changesets = await new StagingAreaManager(model.rootPath, model).list();
+    if (isTelemetryEnabled && span && span.setAttribute("changeset.count", changesets.length), changesets.length === 0) {
+      console.log(ansis.yellow("No changesets found")), console.log(), isTelemetryEnabled && span && span.setStatus({ code: 0 }), endSpan(span);
       return;
     }
     console.log(ansis.bold(`
 Changesets (${changesets.length}):
 `));
     for (const changeset of changesets) {
-      const statusColor = changeset.status === "applied" ? ansis.green : changeset.status === "reverted" ? ansis.gray : ansis.yellow;
+      const statusColor = changeset.status === "committed" ? ansis.green : changeset.status === "discarded" ? ansis.gray : ansis.yellow;
       console.log(`${statusColor(changeset.status.toUpperCase())} ${ansis.bold(changeset.name)}`), changeset.description && console.log(ansis.dim(`  ${changeset.description}`)), console.log(ansis.dim(`  Changes: ${changeset.getChangeCount()} | Created: ${new Date(changeset.created).toLocaleDateString()}`));
       const changesByType = {
         add: changeset.getChangesByType("add").length,
@@ -40,92 +66,498 @@ Changesets (${changesets.length}):
       }, parts = [];
       changesByType.add > 0 && parts.push(`+${changesByType.add}`), changesByType.update > 0 && parts.push(`~${changesByType.update}`), changesByType.delete > 0 && parts.push(`-${changesByType.delete}`), parts.length > 0 && console.log(ansis.dim(`  ${parts.join(" ")}`)), console.log();
     }
+    isTelemetryEnabled && span && span.setStatus({ code: 0 });
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
-async function changesetApplyCommand(name) {
+async function changesetApplyCommand(name, options) {
+  const span = isTelemetryEnabled ? startSpan("changeset.apply", {
+    "changeset.name": name,
+    "apply.validate": options?.validate !== !1,
+    "apply.force": options?.force === !0
+  }) : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new ChangesetManager(model.rootPath), changeset = await manager.load(name);
-    changeset || (console.error(ansis.red(`Error: Changeset '${name}' not found`)), process.exit(1)), console.log(ansis.bold(`
+    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    changeset || (console.error(ansis.red(`Error: Changeset '${name}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1)), isTelemetryEnabled && span && (span.setAttribute("changeset.id", changeset.id), span.setAttribute("changeset.changeCount", changeset.changes.length)), console.log(ansis.bold(`
 Applying changeset: ${ansis.cyan(name)}
-`)), console.log(ansis.dim(`Changes: ${changeset.getChangeCount()}`));
-    const result = await manager.apply(model, name);
-    if (console.log(), console.log(ansis.green(`\u2713 Applied ${result.applied} change(s) from changeset`)), result.failed > 0) {
+`)), console.log(ansis.dim(`Changes: ${changeset.changes.length}`));
+    const preApplyStats = ValidationFormatter.calculateStats(model);
+    preApplyStats.orphanedElements.length > 0 && console.log(ansis.dim(`Model health before apply: ${preApplyStats.orphanedElements.length} orphaned element(s) \u2014 run 'dr validate --orphans' for details`));
+    const changesetId = changeset.id || name;
+    changesetId || (console.error(ansis.red("Error: Changeset ID could not be determined") + `
+` + ansis.dim("This indicates a corrupted changeset. The changeset exists but has no ID field.") + `
+` + ansis.dim(`Try:
+`) + ansis.dim(`  1. Run 'dr changeset list' to see available changesets
+`) + ansis.dim(`  2. Delete and recreate the changeset if possible
+`) + ansis.dim("  3. Contact support if this persists")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset ID missing" }), endSpan(span), process.exit(1));
+    const result = await manager.apply(model, changesetId, {
+      validate: options?.validate,
+      force: options?.force
+    });
+    if (console.log(), console.log(ansis.green(`\u2713 Applied ${result.committed} change(s) from changeset`)), isTelemetryEnabled && span && (span.setAttribute("apply.committed", result.committed), span.setAttribute("apply.failed", result.failed), span.setAttribute("apply.validationPassed", result.validation.passed)), result.failed > 0) {
       console.log(ansis.red(`\u2717 Failed to apply ${result.failed} change(s):`));
-      for (const error of result.errors)
-        console.log(ansis.dim(`  - ${error.change.elementId} (${error.change.type}): ${error.error}`));
+      for (const error of result.validation.errors)
+        console.log(ansis.dim(`  - ${error}`));
     }
     model.manifest.changeset_history || (model.manifest.changeset_history = []), model.manifest.changeset_history.push({
       name,
-      applied_at: (/* @__PURE__ */ new Date()).toISOString(),
-      action: "applied"
-    }), await model.saveDirtyLayers(), await model.saveManifest(), result.failed === 0 && console.log(ansis.dim("Changeset marked as applied")), console.log();
+      committed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "committed"
+    }), await model.saveDirtyLayers(), await model.saveManifest(), result.failed === 0 && console.log(ansis.dim("Changeset marked as committed")), isTelemetryEnabled && span && span.setStatus({ code: 0 }), console.log();
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
 async function changesetRevertCommand(name) {
+  const span = isTelemetryEnabled ? startSpan("changeset.revert", {
+    "changeset.name": name
+  }) : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new ChangesetManager(model.rootPath), changeset = await manager.load(name);
-    changeset || (console.error(ansis.red(`Error: Changeset '${name}' not found`)), process.exit(1)), console.log(ansis.bold(`
+    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    changeset || (console.error(ansis.red(`Error: Changeset '${name}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1)), isTelemetryEnabled && span && (span.setAttribute("changeset.id", changeset.id), span.setAttribute("changeset.changeCount", changeset.changes.length)), console.log(ansis.bold(`
 Reverting changeset: ${ansis.cyan(name)}
-`)), console.log(ansis.dim(`Changes to revert: ${changeset.getChangeCount()}`));
-    const result = await manager.revert(model, name);
-    if (console.log(), console.log(ansis.green(`\u2713 Reverted ${result.reverted} change(s)`)), result.failed > 0) {
-      console.log(ansis.red(`\u2717 Failed to revert ${result.failed} change(s):`));
-      for (const error of result.errors)
-        console.log(ansis.dim(`  - ${error.change.elementId} (${error.change.type}): ${error.error}`));
-    }
-    model.manifest.changeset_history || (model.manifest.changeset_history = []), model.manifest.changeset_history.push({
-      name,
-      applied_at: (/* @__PURE__ */ new Date()).toISOString(),
-      action: "reverted"
-    }), await model.saveDirtyLayers(), await model.saveManifest(), result.failed === 0 && console.log(ansis.dim("Changeset marked as reverted")), console.log();
+`)), console.log(ansis.dim(`Changes to discard: ${changeset.changes.length}`));
+    const changesetId = changeset.id || name;
+    changesetId || (console.error(ansis.red("Error: Changeset ID could not be determined")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset ID missing" }), endSpan(span), process.exit(1)), await manager.revert(changesetId), console.log(), console.log(ansis.green(`\u2713 Reverted changeset: ${name}`)), console.log(ansis.dim("Changeset marked as discarded")), isTelemetryEnabled && span && span.setStatus({ code: 0 }), console.log();
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
 async function changesetActivateCommand(name) {
+  const span = isTelemetryEnabled ? startSpan("changeset.activate", {
+    "changeset.name": name
+  }) : null;
   try {
     const model = await Model.load(process.cwd(), { lazyLoad: !0 });
-    await new ActiveChangesetContext(model.rootPath).setActive(name), console.log(ansis.green(`\u2713 Activated changeset: ${ansis.bold(name)}`)), console.log(ansis.dim("  All model changes will now be tracked in this changeset"));
+    await new StagingAreaManager(model.rootPath, model).setActive(name), console.log(ansis.green(`\u2713 Activated changeset: ${ansis.bold(name)}`)), console.log(ansis.dim("  All model changes will now be tracked in this changeset")), isTelemetryEnabled && span && span.setStatus({ code: 0 });
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
 async function changesetDeactivateCommand() {
+  const span = isTelemetryEnabled ? startSpan("changeset.deactivate") : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), context = new ActiveChangesetContext(model.rootPath), active = await context.getActive();
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), active = await manager.getActiveId();
     if (!active) {
-      console.log(ansis.yellow("No active changeset"));
+      console.log(ansis.yellow("No active changeset")), isTelemetryEnabled && span && (span.setAttribute("changeset.wasActive", !1), span.setStatus({ code: 0 })), endSpan(span);
       return;
     }
-    await context.clearActive(), console.log(ansis.green(`\u2713 Deactivated changeset: ${ansis.bold(active)}`));
+    isTelemetryEnabled && span && (span.setAttribute("changeset.name", active), span.setAttribute("changeset.wasActive", !0)), await manager.clearActive(), console.log(ansis.green(`\u2713 Deactivated changeset: ${ansis.bold(active)}`)), isTelemetryEnabled && span && span.setStatus({ code: 0 });
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetDeleteCommand(name, options) {
+  const span = isTelemetryEnabled ? startSpan("changeset.delete", {
+    "changeset.name": name,
+    "delete.force": options.force === !0
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    if (changeset || (console.error(ansis.red(`Error: Changeset '${name}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1)), await manager.getActiveId() === changeset.id && (console.error(ansis.red(`Error: Cannot delete active changeset '${name}'`)), console.log(ansis.dim("  Run `dr changeset deactivate` first")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Cannot delete active changeset" }), endSpan(span), process.exit(1)), !options.force) {
+      const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+      if (isTelemetryEnabled && span && span.setAttribute("cli.interactive", isInteractive), isInteractive) {
+        const confirm = await prompts.confirm({
+          message: `Delete changeset '${name}'? This cannot be undone.`
+        });
+        if (!confirm || typeof confirm != "boolean") {
+          console.log(ansis.yellow("Deletion cancelled")), isTelemetryEnabled && span && (span.setAttribute("delete.cancelled", !0), span.setStatus({ code: 0 })), endSpan(span);
+          return;
+        }
+      } else
+        console.error(ansis.red("Error: Cannot confirm deletion in non-interactive environment")), console.log(ansis.dim("  Use --force flag to confirm deletion")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Interactive confirmation required" }), endSpan(span), process.exit(1);
+    }
+    await manager.delete(name), console.log(ansis.green(`\u2713 Deleted changeset: ${ansis.bold(name)}`)), isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
 async function changesetStatusCommand() {
+  const span = isTelemetryEnabled ? startSpan("changeset.status") : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), active = await new ActiveChangesetContext(model.rootPath).getActive();
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), active = await manager.getActiveId();
     if (!active) {
-      console.log(ansis.dim("No active changeset"));
+      console.log(ansis.dim("No active changeset")), isTelemetryEnabled && span && (span.setAttribute("changeset.hasActive", !1), span.setStatus({ code: 0 })), endSpan(span);
       return;
     }
-    console.log(ansis.bold(`Active changeset: ${ansis.cyan(active)}`));
-    const changeset = await new ChangesetManager(model.rootPath).load(active);
+    isTelemetryEnabled && span && (span.setAttribute("changeset.name", active), span.setAttribute("changeset.hasActive", !0)), console.log(ansis.bold(`Active changeset: ${ansis.cyan(active)}`));
+    const changeset = await manager.load(active);
     if (changeset) {
-      console.log(ansis.dim(`  Changes tracked: ${changeset.getChangeCount()}`));
-      const changesByType = {
-        add: changeset.getChangesByType("add").length,
-        update: changeset.getChangesByType("update").length,
-        delete: changeset.getChangesByType("delete").length
-      }, parts = [];
-      changesByType.add > 0 && parts.push(`+${changesByType.add}`), changesByType.update > 0 && parts.push(`~${changesByType.update}`), changesByType.delete > 0 && parts.push(`-${changesByType.delete}`), parts.length > 0 && console.log(ansis.dim(`  ${parts.join(" ")}`));
+      console.log(ansis.dim(`  Changes tracked: ${changeset.changes.length}`));
+      const changesByType = changeset.stats;
+      isTelemetryEnabled && span && (span.setAttribute("changeset.changeCount", changeset.changes.length), span.setAttribute("changeset.adds", changesByType.additions), span.setAttribute("changeset.updates", changesByType.modifications), span.setAttribute("changeset.deletes", changesByType.deletions));
+      const parts = [];
+      changesByType.additions > 0 && parts.push(`+${changesByType.additions}`), changesByType.modifications > 0 && parts.push(`~${changesByType.modifications}`), changesByType.deletions > 0 && parts.push(`-${changesByType.deletions}`), parts.length > 0 && console.log(ansis.dim(`  ${parts.join(" ")}`));
+    }
+    isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetStagedCommand(options) {
+  const span = isTelemetryEnabled ? startSpan("changeset.staged", {
+    "staged.layer": options.layer
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), activeChangeset = await manager.getActiveId();
+    if (!activeChangeset) {
+      console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "No active changeset" }), endSpan(span);
+      return;
+    }
+    const changeset = await manager.load(activeChangeset);
+    changeset || (console.error(ansis.red(`Error: Changeset '${activeChangeset}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1));
+    let changes = changeset.changes;
+    if (options.layer && (changes = changes.filter((c) => c.layerName === options.layer)), isTelemetryEnabled && span && (span.setAttribute("staged.changeCount", changes.length), span.setAttribute("staged.totalChanges", changeset.changes.length)), changes.length === 0) {
+      console.log(ansis.yellow("No staged changes")), isTelemetryEnabled && span && span.setStatus({ code: 0 }), endSpan(span);
+      return;
+    }
+    console.log(ansis.bold(`
+Staged Changes (${changes.length}):
+`));
+    const tableData = changes.map((c) => ({
+      "Element ID": c.elementId,
+      Layer: c.layerName,
+      Type: c.type,
+      Timestamp: new Date(c.timestamp || Date.now()).toISOString()
+    }));
+    console.table(tableData), isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetExplicitStageCommand(elementId) {
+  const span = isTelemetryEnabled ? startSpan("changeset.stage-explicit", { "stage.elementId": elementId }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await manager.getActiveId();
+    if (!activeChangesetId) {
+      console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "No active changeset" }), endSpan(span);
+      return;
+    }
+    const layerName = await findElementLayer(model, elementId);
+    layerName || (console.error(ansis.red(`Error: Element '${elementId}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Element not found" }), endSpan(span), process.exit(1));
+    const element = (await model.getLayer(layerName))?.getElement(elementId);
+    if (element || (console.error(ansis.red(`Error: Element '${elementId}' not found in layer '${layerName}'`)), endSpan(span), process.exit(1)), (await manager.load(activeChangesetId))?.changes.some((c) => c.elementId === elementId)) {
+      console.warn(ansis.yellow(`Warning: Element '${elementId}' is already staged in the active changeset. Skipping.`)), endSpan(span);
+      return;
+    }
+    await manager.stage(activeChangesetId, {
+      type: "add",
+      elementId,
+      layerName,
+      after: element.toJSON()
+    }), isTelemetryEnabled && span && (span.setAttribute("stage.layerName", layerName), span.setStatus({ code: 0 })), console.log(ansis.green(`\u2713 Staged element: ${ansis.bold(elementId)}`)), console.log(ansis.dim(`  Layer: ${layerName} | Changeset: ${activeChangesetId}`));
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({ code: 2, message: getErrorMessage(error) })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetUnstageCommand(elementId) {
+  const span = isTelemetryEnabled ? startSpan("changeset.unstage", {
+    "unstage.elementId": elementId
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await manager.getActiveId();
+    if (!activeChangesetId) {
+      console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "No active changeset" }), endSpan(span);
+      return;
+    }
+    const changeset = await manager.load(activeChangesetId);
+    changeset || (console.error(ansis.red(`Error: Changeset '${activeChangesetId}' not found`)), process.exit(1));
+    const initialCount = changeset.changes.length;
+    await manager.unstage(activeChangesetId, elementId);
+    const updated = await manager.load(activeChangesetId);
+    if (updated && updated.changes.length === initialCount) {
+      console.error(ansis.yellow(`Warning: Element '${elementId}' not found in staged changes`)), isTelemetryEnabled && span && (span.setAttribute("unstage.found", !1), span.setStatus({ code: 0 })), endSpan(span);
+      return;
+    }
+    isTelemetryEnabled && span && (span.setAttribute("unstage.found", !0), span.setAttribute("unstage.remainingChanges", updated?.getChangeCount() || 0)), console.log(ansis.green(`\u2713 Unstaged element: ${ansis.bold(elementId)}`)), console.log(ansis.dim(`  Remaining staged changes: ${updated?.getChangeCount() || 0}`)), isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetDiscardCommand(elementId) {
+  const span = isTelemetryEnabled ? startSpan("changeset.discard", {
+    "discard.elementId": elementId,
+    "discard.all": !elementId
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await manager.getActiveId();
+    if (!activeChangesetId) {
+      console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "No active changeset" }), endSpan(span);
+      return;
+    }
+    const changeset = await manager.load(activeChangesetId);
+    if (changeset || (console.error(ansis.red(`Error: Changeset '${activeChangesetId}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1)), isTelemetryEnabled && span && span.setAttribute("discard.changeCount", changeset.changes.length), elementId) {
+      const initialCount = changeset.changes.length;
+      await manager.unstage(activeChangesetId, elementId);
+      const updated = await manager.load(activeChangesetId);
+      if (updated && updated.changes.length === initialCount) {
+        console.error(ansis.yellow(`Warning: Element '${elementId}' not found in staged changes`)), isTelemetryEnabled && span && (span.setAttribute("discard.found", !1), span.setStatus({ code: 0 })), endSpan(span);
+        return;
+      }
+      isTelemetryEnabled && span && span.setAttribute("discard.found", !0), console.log(ansis.green(`\u2713 Discarded changes for element: ${ansis.bold(elementId)}`));
+    } else {
+      const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+      if (isTelemetryEnabled && span && span.setAttribute("cli.interactive", isInteractive), isInteractive) {
+        const confirmed = await prompts.confirm({
+          message: `Discard all ${changeset.changes.length} staged changes? This cannot be undone.`
+        });
+        if (!confirmed || typeof confirmed != "boolean") {
+          console.log(ansis.dim("Cancelled")), isTelemetryEnabled && span && (span.setAttribute("discard.cancelled", !0), span.setStatus({ code: 0 })), endSpan(span);
+          return;
+        }
+      } else
+        console.error(ansis.red("Error: Cannot confirm discard of all changes in non-interactive environment")), console.log(ansis.dim("  Specify an element ID to discard only that element")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Interactive confirmation required" }), endSpan(span), process.exit(1);
+      await manager.discard(activeChangesetId), console.log(ansis.green("\u2713 Discarded all staged changes")), console.log(ansis.dim("  Changeset status: discarded"));
+    }
+    isTelemetryEnabled && span && span.setStatus({ code: 0 }), console.log();
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetPreviewCommand(options) {
+  const span = isTelemetryEnabled ? startSpan("changeset.preview", {
+    "preview.layer": options.layer
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await manager.getActiveId();
+    if (!activeChangesetId) {
+      console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "No active changeset" }), endSpan(span);
+      return;
+    }
+    const changeset = await manager.load(activeChangesetId);
+    changeset || (console.error(ansis.red(`Error: Changeset '${activeChangesetId}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1)), console.log(ansis.bold(`
+Preview: Merged Model State (${ansis.cyan("with staged changes")})`)), console.log(ansis.dim(`Changeset: ${changeset.name}`)), console.log();
+    const additions = changeset.getChangesByType("add").length, modifications = changeset.getChangesByType("update").length, deletions = changeset.getChangesByType("delete").length;
+    if (isTelemetryEnabled && span && (span.setAttribute("preview.additions", additions), span.setAttribute("preview.modifications", modifications), span.setAttribute("preview.deletions", deletions), span.setAttribute("preview.totalChanges", changeset.changes.length)), additions > 0 && console.log(ansis.green(`+ ${additions} additions`)), modifications > 0 && console.log(ansis.yellow(`~ ${modifications} modifications`)), deletions > 0 && console.log(ansis.red(`- ${deletions} deletions`)), console.log(), options.layer) {
+      const layerChanges = changeset.changes.filter((c) => c.layerName === options.layer);
+      if (layerChanges.length === 0) {
+        console.log(ansis.dim(`No staged changes in layer '${options.layer}'`));
+        return;
+      }
+      console.log(ansis.bold(`Layer: ${options.layer}`));
+      const tableData = layerChanges.map((c) => ({
+        "Element ID": c.elementId + ansis.dim(" (staged)"),
+        Type: c.type,
+        Status: c.type === "add" ? "new" : c.type === "delete" ? "removed" : "updated"
+      }));
+      console.table(tableData);
+    } else {
+      const layerMap = /* @__PURE__ */ new Map();
+      changeset.changes.forEach((c) => {
+        const existing = layerMap.get(c.layerName) ?? [];
+        existing.push(c), layerMap.set(c.layerName, existing);
+      }), isTelemetryEnabled && span && span.setAttribute("preview.layerCount", layerMap.size);
+      for (const [layerName, changes] of layerMap) {
+        console.log(ansis.bold(`Layer: ${layerName}`));
+        const tableData = changes.map((c) => ({
+          "Element ID": c.elementId,
+          Type: c.type,
+          Status: c.type === "add" ? "new" : c.type === "delete" ? "removed" : "updated"
+        }));
+        console.table(tableData), console.log();
+      }
+    }
+    isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetDiffCommand(options) {
+  const span = isTelemetryEnabled ? startSpan("changeset.diff", {
+    "diff.layer": options.layer
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await manager.getActiveId();
+    if (!activeChangesetId) {
+      console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "No active changeset" }), endSpan(span);
+      return;
+    }
+    const changeset = await manager.load(activeChangesetId);
+    changeset || (console.error(ansis.red(`Error: Changeset '${activeChangesetId}' not found`)), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset not found" }), endSpan(span), process.exit(1)), console.log(ansis.bold(`
+Diff: Base Model vs Staged Changes
+`));
+    const layerMap = /* @__PURE__ */ new Map();
+    if (changeset.changes.forEach((c) => {
+      if (!options.layer || c.layerName === options.layer) {
+        const existing = layerMap.get(c.layerName) ?? [];
+        existing.push(c), layerMap.set(c.layerName, existing);
+      }
+    }), isTelemetryEnabled && span && (span.setAttribute("diff.layerCount", layerMap.size), span.setAttribute("diff.totalChanges", changeset.changes.length)), layerMap.size === 0) {
+      console.log(ansis.dim(options.layer ? `No changes in layer '${options.layer}'` : "No staged changes")), isTelemetryEnabled && span && span.setStatus({ code: 0 }), endSpan(span);
+      return;
+    }
+    for (const [layerName, changes] of layerMap) {
+      console.log(ansis.bold(`Layer: ${layerName}`));
+      for (const change of changes)
+        change.type === "add" ? (console.log(ansis.green(`+ ${change.elementId}`)), console.log(ansis.dim(`  ${JSON.stringify(change.after || {}, null, 2)}`))) : change.type === "delete" ? (console.log(ansis.red(`- ${change.elementId}`)), console.log(ansis.dim(`  ${JSON.stringify(change.before || {}, null, 2)}`))) : change.type === "update" && (console.log(ansis.yellow(`~ ${change.elementId}`)), console.log(ansis.dim(`  Before: ${JSON.stringify(change.before || {})}`)), console.log(ansis.dim(`  After:  ${JSON.stringify(change.after || {})}`)));
+      console.log();
+    }
+    isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetCommitCommand(options) {
+  await startActiveSpan("changeset.commit", async (span) => {
+    try {
+      const model = await Model.load(process.cwd(), { lazyLoad: !1 }), stagingManager = new StagingAreaManager(model.rootPath, model), activeChangesetId = await stagingManager.getActiveId();
+      if (!activeChangesetId) {
+        console.error(ansis.red("Error: No active changeset")), isTelemetryEnabled && span.setStatus({ code: 2, message: "No active changeset" });
+        return;
+      }
+      const changeset = await stagingManager.load(activeChangesetId);
+      changeset || (console.error(ansis.red(`Error: Changeset '${activeChangesetId}' not found`)), isTelemetryEnabled && span.setStatus({ code: 2, message: "Changeset not found" }), span.end(), process.exit(1));
+      const changeCount = changeset.changes.length;
+      if (isTelemetryEnabled && (span.setAttribute("changeset.id", activeChangesetId), span.setAttribute("changeset.name", changeset.name), span.setAttribute("changeset.changeCount", changeCount)), changeCount === 0) {
+        console.log(ansis.yellow("No staged changes to commit")), isTelemetryEnabled && span.setStatus({ code: 0 });
+        return;
+      }
+      console.log(ansis.bold(`
+Committing changeset: ${ansis.cyan(changeset.name)}`)), console.log(ansis.dim(`Staged changes: ${changeCount}`)), console.log();
+      try {
+        const result = await stagingManager.commit(model, activeChangesetId, {
+          validate: options?.validate !== !1,
+          force: options?.force === !0
+        });
+        if (await stagingManager.clearActive(), console.log(ansis.green(`\u2713 Committed ${result.committed} change(s)`)), (result.skipped ?? 0) > 0) {
+          const skipped = result.skipped, details = result.skippedDetails ?? [];
+          console.log(ansis.yellow(`\u26A0 Skipped ${skipped} duplicate element(s):`));
+          const shown = details.slice(0, 10);
+          for (const detail of shown)
+            console.log(ansis.dim(`    ${detail}`));
+          details.length > 10 && console.log(ansis.dim(`    ... and ${details.length - 10} more`));
+        }
+        isTelemetryEnabled && (span.setAttribute("commit.committed", result.committed), span.setAttribute("commit.skipped", result.skipped), span.setAttribute("commit.failed", result.failed), span.setAttribute("commit.validationPassed", result.validation.passed));
+        const accountedFor = result.committed + (result.skipped ?? 0) + result.failed;
+        if (accountedFor < changeCount) {
+          const unaccounted = changeCount - accountedFor;
+          console.log(ansis.yellow(`\u26A0 Warning: ${unaccounted} staged change(s) were not applied, skipped, or reported as failed. This is unexpected \u2014 check the changeset log for details.`));
+        }
+        result.driftWarning && (console.log(ansis.yellow("\u26A0 Warning: Model had drifted since changeset creation (--force was used)")), isTelemetryEnabled && span.setAttribute("commit.driftDetected", !0)), isTelemetryEnabled && span.setStatus({ code: 0 }), console.log();
+      } catch (error) {
+        throw console.log(ansis.red(`\u2717 Commit failed and rolled back: ${getErrorMessage(error)}`)), isTelemetryEnabled && span.setAttribute("commit.rolledBack", !0), error;
+      }
+    } catch (error) {
+      isTelemetryEnabled && (span.recordException(error), span.setStatus({
+        code: 2,
+        message: getErrorMessage(error)
+      })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), span.end(), process.exit(1);
+    }
+  }, {
+    "commit.validate": options?.validate !== !1,
+    "commit.force": options?.force === !0
+  });
+}
+async function changesetExportCommand(changesetId, options) {
+  const format = options.format || "yaml", span = isTelemetryEnabled ? startSpan("changeset.export", {
+    "changeset.id": changesetId,
+    "export.format": format
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), exporter = new ChangesetExporter(model.rootPath), ext = format === "patch" ? "patch" : format, outputPath = options.output || `${changesetId}.${ext}`, absolutePath = path.isAbsolute(outputPath) ? outputPath : path.join(process.cwd(), outputPath);
+    isTelemetryEnabled && span && span.setAttribute("export.outputPath", outputPath), await exporter.exportToFile(changesetId, absolutePath, format), console.log(ansis.green(`\u2713 Exported changeset to ${ansis.cyan(outputPath)}`)), console.log(ansis.dim(`  Format: ${format}`)), isTelemetryEnabled && span && span.setStatus({ code: 0 });
+  } catch (error) {
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
+  }
+}
+async function changesetImportCommand(file, options = {}) {
+  const span = isTelemetryEnabled ? startSpan("changeset.import", {
+    "import.file": file,
+    "import.force": options.force === !0
+  }) : null;
+  try {
+    const model = await Model.load(process.cwd(), { lazyLoad: !1 }), exporter = new ChangesetExporter(model.rootPath), absolutePath = path.isAbsolute(file) ? file : path.join(process.cwd(), file), imported = await exporter.importFromFile(absolutePath);
+    isTelemetryEnabled && span && (span.setAttribute("changeset.name", imported.name), span.setAttribute("changeset.changeCount", imported.changes.length));
+    const compatibility = await exporter.validateCompatibility(imported, model);
+    if (isTelemetryEnabled && span && (span.setAttribute("import.compatible", compatibility.compatible), span.setAttribute("import.baseSnapshotMatch", compatibility.baseSnapshotMatch)), !compatibility.compatible) {
+      console.error(ansis.red("\u2717 Import failed: Changeset is incompatible")), console.error(ansis.dim("  Issues:"));
+      for (const warning of compatibility.warnings)
+        console.error(ansis.dim(`    - ${warning}`));
+      isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset incompatible" }), endSpan(span), process.exit(1);
     }
+    compatibility.baseSnapshotMatch || (options.force || (console.error(ansis.red("Error: Imported changeset has base model drift") + `
+` + ansis.dim("The model has been modified since this changeset was created.") + `
+` + ansis.dim("This may cause conflicts or unexpected behavior when committing.") + `
+
+` + ansis.dim("To import anyway, use: --force")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Drift detected, force required" }), endSpan(span), process.exit(1)), console.warn(ansis.yellow("\u26A0 Warning: Base model drift detected (--force used)") + `
+` + ansis.dim("Review changes carefully before committing.")), console.log(), isTelemetryEnabled && span && span.setAttribute("import.driftOverridden", !0));
+    const newId = generateImportedChangesetId();
+    imported.id = newId, await new StagedChangesetStorage(model.rootPath).save(imported), console.log(ansis.green(`\u2713 Imported changeset: ${ansis.cyan(imported.name)}`)), console.log(ansis.dim(`  ID: ${newId}`)), console.log(ansis.dim(`  Changes: +${imported.stats?.additions || 0} ~${imported.stats?.modifications || 0} -${imported.stats?.deletions || 0}`)), compatibility.baseSnapshotMatch || console.log(ansis.yellow("  \u26A0 Base model drift detected - review before committing")), isTelemetryEnabled && span && (span.setAttribute("changeset.id", newId), span.setStatus({ code: 0 })), console.log();
   } catch (error) {
-    console.error(ansis.red(`Error: ${error instanceof Error ? error.message : String(error)}`)), process.exit(1);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
+      code: 2,
+      message: getErrorMessage(error)
+    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+  } finally {
+    endSpan(span);
   }
 }
 function changesetCommands(program) {
@@ -139,10 +571,12 @@ Examples:
 Examples:
   $ dr changeset list`).action(async () => {
     await changesetListCommand();
-  }), changesetGroup.command("apply <name>").description("Apply a changeset to the model").addHelpText("after", `
+  }), changesetGroup.command("apply <name>").description("Apply a changeset to the model").option("--no-validate", "Skip validation before applying").option("--force", "Force apply even if base model has drifted").addHelpText("after", `
 Examples:
-  $ dr changeset apply "v1.1 migration"`).action(async (name) => {
-    await changesetApplyCommand(name);
+  $ dr changeset apply "v1.1 migration"
+  $ dr changeset apply "v1.1 migration" --no-validate
+  $ dr changeset apply "v1.1 migration" --force`).action(async (name, options) => {
+    await changesetApplyCommand(name, options);
   }), changesetGroup.command("revert <name>").description("Revert a changeset from the model").addHelpText("after", `
 Examples:
   $ dr changeset revert "v1.1 migration"`).action(async (name) => {
@@ -159,16 +593,93 @@ Examples:
 Examples:
   $ dr changeset status`).action(async () => {
     await changesetStatusCommand();
-  });
+  }), changesetGroup.command("show [name]").description("Show changeset details (use: status, staged, diff, or preview)").addHelpText("after", `
+To inspect a changeset, use one of:
+  $ dr changeset status              # Show the active changeset
+  $ dr changeset staged              # List all staged changes
+  $ dr changeset diff [name]         # Show a diff of staged changes
+  $ dr changeset preview [name]      # Preview what will be committed`).action(async (name) => {
+    const nameHint = name ? ` '${name}'` : "";
+    console.error(`error: 'dr changeset show${nameHint}' is not a valid subcommand.
+
+To inspect a changeset, use one of:
+  dr changeset status        \u2014 show the active changeset
+  dr changeset staged        \u2014 list all staged changes
+  dr changeset diff          \u2014 show a diff of staged changes
+  dr changeset preview       \u2014 preview what will be committed`), process.exit(1);
+  }), changesetGroup.command("delete <name>").description("Delete a changeset permanently").option("-f, --force", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  $ dr changeset delete my-feature
+  $ dr changeset delete my-feature --force`).action(async (name, options) => {
+    await changesetDeleteCommand(name, options);
+  }), changesetGroup.command("staged").description("List all staged changes in the active changeset").option("-l, --layer <layer>", "Filter by layer name").addHelpText("after", `
+Examples:
+  $ dr changeset staged
+  $ dr changeset staged --layer api`).action(async (options) => {
+    await changesetStagedCommand(options);
+  }), changesetGroup.command("stage <element-id>").description("Stage a specific element into the active changeset").addHelpText("after", `
+Examples:
+  $ dr changeset stage api.operation.get-users
+  $ dr changeset stage ux.uicomponent.login-form`).action(async (elementId) => {
+    await changesetExplicitStageCommand(elementId);
+  }), changesetGroup.command("unstage <element-id>").description("Remove specific element from staging area").addHelpText("after", `
+Examples:
+  $ dr changeset unstage api-endpoint-create-customer`).action(async (elementId) => {
+    await changesetUnstageCommand(elementId);
+  }), changesetGroup.command("discard [element-id]").description("Discard all or single staged changes").addHelpText("after", `
+Examples:
+  $ dr changeset discard
+  $ dr changeset discard api-endpoint-create-customer`).action(async (elementId) => {
+    await changesetDiscardCommand(elementId);
+  }), changesetGroup.command("preview").description("Preview the merged model state with staged changes applied").option("-l, --layer <layer>", "Preview specific layer only").addHelpText("after", `
+Examples:
+  $ dr changeset preview
+  $ dr changeset preview --layer application`).action(async (options) => {
+    await changesetPreviewCommand(options);
+  }), changesetGroup.command("diff").description("Show delta between base model and staged changes").option("-l, --layer <layer>", "Show diff for specific layer only").addHelpText("after", `
+Examples:
+  $ dr changeset diff
+  $ dr changeset diff --layer api`).action(async (options) => {
+    await changesetDiffCommand(options);
+  }), changesetGroup.command("commit").description("Apply staged changes to the base model").option("--validate", "Run validation before commit (default: true)", !0).option("--force", "Commit despite drift warnings", !1).addHelpText("after", `
+Examples:
+  $ dr changeset commit
+  $ dr changeset commit --validate
+  $ dr changeset commit --force`).action(async (options) => {
+    await changesetCommitCommand(options);
+  }), changesetGroup.command("export <changeset-id>").description("Export changeset to portable file").option("-o, --output <file>", "Output file path").option("-f, --format <format>", "Export format (yaml|json|patch)", "yaml").addHelpText("after", `
+Examples:
+  $ dr changeset export api-updates
+  $ dr changeset export api-updates --output changes.yaml
+  $ dr changeset export api-updates --format json --output changes.json
+  $ dr changeset export api-updates --format patch --output changes.patch`).action(async (changesetId, options) => {
+    await changesetExportCommand(changesetId, options);
+  }), changesetGroup.command("import <file>").description("Import changeset from file").option("-f, --force", "Import despite base model drift", !1).addHelpText("after", `
+Examples:
+  $ dr changeset import changes.yaml
+  $ dr changeset import ../team-changes.json
+  $ dr changeset import changes.yaml --force`).action(async (file, options) => {
+    await changesetImportCommand(file, options);
+  }), changesetGroup.showSuggestionAfterError();
 }
 export {
   changesetActivateCommand,
   changesetApplyCommand,
   changesetCommands,
+  changesetCommitCommand,
   changesetCreateCommand,
   changesetDeactivateCommand,
+  changesetDeleteCommand,
+  changesetDiffCommand,
+  changesetDiscardCommand,
+  changesetExplicitStageCommand,
+  changesetExportCommand,
+  changesetImportCommand,
   changesetListCommand,
+  changesetPreviewCommand,
   changesetRevertCommand,
-  changesetStatusCommand
+  changesetStagedCommand,
+  changesetStatusCommand,
+  changesetUnstageCommand
 };
 //# sourceMappingURL=changeset.js.map