@documentation-robotics/cli 0.1.13 → 0.3.0

package/dist/commands/changeset.js

@@ -4,11 +4,14 @@ 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 { Option } from "commander";
 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 { getErrorMessage, handleSuccess, handleInfo, handleWarning } from "../utils/errors.js";
+import { isJson } from "../utils/globals.js";
 import { findElementLayer } from "../utils/element-utils.js";
+import { changesetVerifyCommand } from "./changeset-verify.js";
 function generateImportedChangesetId() {
   return `imported-${Date.now()}`;
 }
@@ -18,8 +21,8 @@ async function changesetCreateCommand(name, options) {
     "changeset.hasDescription": !!options.description
   }) : null;
   try {
-    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));
+    const model = await Model.load(options.model, { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model);
+    await manager.load(name) && (isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: `Changeset '${name}' already exists` })) : 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 isInteractive = process.stdin.isTTY;
@@ -31,24 +34,30 @@ async function changesetCreateCommand(name, options) {
       }
     }
     const changeset = await manager.create(name, description || void 0), previouslyActive = await manager.getActiveId();
-    if (previouslyActive) {
+    if (previouslyActive && !isJson()) {
       const previous = await manager.load(previouslyActive);
       console.log(ansis.yellow(`  Deactivating changeset: ${ansis.bold(previous?.name ?? previouslyActive)}`));
     }
-    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();
+    await manager.setActive(changeset.id), isTelemetryEnabled && span && (span.setAttribute("changeset.id", changeset.id), span.setStatus({ code: 0 }));
+    const createDetails = {
+      changesetId: changeset.id,
+      changesetName: name,
+      path: `documentation-robotics/changesets/${changeset.id}/`
+    };
+    changeset.description && (createDetails.description = changeset.description), handleSuccess(`Created and activated changeset: ${ansis.bold(name)}`, createDetails, { verbose: !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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetListCommand() {
+async function changesetListCommand(options = {}) {
   const span = isTelemetryEnabled ? startSpan("changeset.list") : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), changesets = await new StagingAreaManager(model.rootPath, model).list();
+    const model = await Model.load(options.model, { 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;
@@ -71,11 +80,19 @@ Changesets (${changesets.length}):
     isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
       code: 2,
       message: getErrorMessage(error)
-    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
+function reportCommitValidation(result, details) {
+  if (result.validation.ran === !1) {
+    delete details.validationPassed, details.validationSkipped = !0, isJson() || console.log(ansis.yellow("\u26A0 Validation skipped (--no-validate); run 'dr validate' to check the result"));
+    return;
+  }
+  const preExisting = result.validation.preExistingErrors ?? 0;
+  details.preExistingErrors = preExisting, preExisting > 0 && (details.preExistingSample = result.validation.preExistingSample ?? [], isJson() || console.log(ansis.yellow(`\u26A0 ${preExisting} validation error(s) already in the base model were ignored; the changeset introduced none. Run 'dr validate' to see them.`)));
+}
 async function changesetApplyCommand(name, options) {
   const span = isTelemetryEnabled ? startSpan("changeset.apply", {
     "changeset.name": name,
@@ -83,92 +100,122 @@ async function changesetApplyCommand(name, options) {
     "apply.force": options?.force === !0
   }) : null;
   try {
-    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(`
+    const model = await Model.load(options?.model, { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    if (changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${name}' not found` })) : 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)), !isJson()) {
+      console.log(ansis.bold(`
 Applying changeset: ${ansis.cyan(name)}
 `)), 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 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") + `
+    if (!changesetId) {
+      const errMsg = "Changeset ID could not be determined";
+      isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: errMsg })) : console.error(ansis.red("Error: " + errMsg) + `
 ` + 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));
+`) + 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):`));
+    handleInfo(""), isTelemetryEnabled && span && (span.setAttribute("apply.committed", result.committed), span.setAttribute("apply.failed", result.failed), span.setAttribute("apply.validationPassed", result.validation.passed));
+    const applyDetails = {
+      changesetName: name,
+      changesetId: changeset.id,
+      committed: result.committed,
+      failed: result.failed,
+      validationPassed: result.validation.passed
+    };
+    if (reportCommitValidation(result, applyDetails), result.failed > 0 && (applyDetails.errors = result.validation.errors, !isJson())) {
+      handleInfo(ansis.red(`\u2717 Failed to apply ${result.failed} change(s):`));
       for (const error of result.validation.errors)
-        console.log(ansis.dim(`  - ${error}`));
+        handleInfo(ansis.dim(`  - ${error}`));
     }
-    model.manifest.changeset_history || (model.manifest.changeset_history = []), model.manifest.changeset_history.push({
+    handleSuccess(`Applied ${result.committed} change(s) from changeset`, applyDetails), model.manifest.changeset_history || (model.manifest.changeset_history = []), model.manifest.changeset_history.push({
       name,
       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();
+    }), await model.saveDirtyLayers(), await model.saveManifest(), result.failed === 0 && handleInfo(ansis.dim("Changeset marked as committed")), isTelemetryEnabled && span && span.setStatus({ code: 0 }), handleInfo("");
   } 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetRevertCommand(name) {
+async function changesetRevertCommand(name, options = {}) {
   const span = isTelemetryEnabled ? startSpan("changeset.revert", {
     "changeset.name": name
   }) : null;
   try {
-    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(`
+    const model = await Model.load(options.model, { lazyLoad: !1 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${name}' not found` })) : 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)), isJson() || (console.log(ansis.bold(`
 Reverting changeset: ${ansis.cyan(name)}
-`)), console.log(ansis.dim(`Changes to discard: ${changeset.changes.length}`));
+`)), 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();
+    if (!changesetId) {
+      const errMsg = "Changeset ID could not be determined";
+      isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: errMsg })) : console.error(ansis.red("Error: " + errMsg) + `
+` + ansis.dim("The changeset must have an ID to proceed with revert.")), isTelemetryEnabled && span && span.setStatus({ code: 2, message: "Changeset ID missing" }), endSpan(span), process.exit(1);
+    }
+    await manager.revert(changesetId), handleInfo(""), handleSuccess(`Reverted changeset: ${name}`, {
+      changesetName: name,
+      changesetId,
+      changesetStatus: "discarded"
+    }), isTelemetryEnabled && span && span.setStatus({ code: 0 }), handleInfo("");
   } 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetActivateCommand(name) {
+async function changesetActivateCommand(name, options = {}) {
   const span = isTelemetryEnabled ? startSpan("changeset.activate", {
     "changeset.name": name
   }) : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 });
-    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 });
+    const model = await Model.load(options.model, { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${name}' not found` })) : 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.setActive(name), handleSuccess(`Activated changeset: ${ansis.bold(name)}`, {
+      changesetName: name,
+      changesetId: changeset.id
+    }), 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetDeactivateCommand() {
+async function changesetDeactivateCommand(options = {}) {
   const span = isTelemetryEnabled ? startSpan("changeset.deactivate") : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), active = await manager.getActiveId();
+    const model = await Model.load(options.model, { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), active = await manager.getActiveId();
     if (!active) {
-      console.log(ansis.yellow("No active changeset")), isTelemetryEnabled && span && (span.setAttribute("changeset.wasActive", !1), span.setStatus({ code: 0 })), endSpan(span);
+      handleInfo(ansis.yellow("No active changeset")), isTelemetryEnabled && span && (span.setAttribute("changeset.wasActive", !1), span.setStatus({ code: 0 })), endSpan(span);
       return;
     }
-    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 });
+    isTelemetryEnabled && span && (span.setAttribute("changeset.name", active), span.setAttribute("changeset.wasActive", !0));
+    const changeset = await manager.load(active);
+    await manager.clearActive(), handleSuccess(`Deactivated changeset: ${ansis.bold(active)}`, {
+      changesetId: active,
+      name: changeset?.name || active
+    }), 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
@@ -179,34 +226,39 @@ async function changesetDeleteCommand(name, options) {
     "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 model = await Model.load(options.model, { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), changeset = await manager.load(name);
+    if (changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${name}' not found` })) : 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 && (isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: `Cannot delete active changeset '${name}'` })) : (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);
+          handleSuccess("Deletion cancelled", {
+            status: "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);
+        isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "Cannot confirm deletion in non-interactive environment" })) : (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 });
+    await manager.delete(name), handleSuccess(`Deleted changeset: ${ansis.bold(name)}`, {
+      changesetName: name,
+      changesetId: changeset.id
+    }), 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetStatusCommand() {
+async function changesetStatusCommand(options = {}) {
   const span = isTelemetryEnabled ? startSpan("changeset.status") : null;
   try {
-    const model = await Model.load(process.cwd(), { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), active = await manager.getActiveId();
+    const model = await Model.load(options.model, { lazyLoad: !0 }), manager = new StagingAreaManager(model.rootPath, model), active = await manager.getActiveId();
     if (!active) {
       console.log(ansis.dim("No active changeset")), isTelemetryEnabled && span && (span.setAttribute("changeset.hasActive", !1), span.setStatus({ code: 0 })), endSpan(span);
       return;
@@ -225,7 +277,7 @@ async function changesetStatusCommand() {
     isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
       code: 2,
       message: getErrorMessage(error)
-    })), console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
@@ -235,49 +287,65 @@ async function changesetStagedCommand(options) {
     "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();
+    const model = await Model.load(options.model, { 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);
+      isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "No active changeset" })) : 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));
+    changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${activeChangeset}' not found` })) : 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);
+      handleSuccess("No staged changes", {
+        changesetId: activeChangeset,
+        changeCount: 0,
+        changes: []
+      }, { verbose: !0 }), isTelemetryEnabled && span && span.setStatus({ code: 0 }), endSpan(span);
       return;
     }
-    console.log(ansis.bold(`
+    if (!isJson()) {
+      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 });
+      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);
+    }
+    handleSuccess(`Listed ${changes.length} staged change(s)`, {
+      changesetId: activeChangeset,
+      changeCount: changes.length,
+      changes: changes.map((c) => ({
+        elementId: c.elementId,
+        layer: c.layerName,
+        operation: c.type,
+        timestamp: new Date(c.timestamp || Date.now()).toISOString()
+      }))
+    }), 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetExplicitStageCommand(elementId) {
+async function changesetExplicitStageCommand(elementId, options = {}) {
   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();
+    const model = await Model.load(options.model, { 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);
+      isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "No active changeset" })) : 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));
+    layerName || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Element '${elementId}' not found` })) : 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)) {
+    if (element || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Element '${elementId}' not found in layer '${layerName}'` })) : 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;
     }
@@ -286,63 +354,74 @@ async function changesetExplicitStageCommand(elementId) {
       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}`));
+    }), isTelemetryEnabled && span && (span.setAttribute("stage.layerName", layerName), span.setStatus({ code: 0 })), handleSuccess(`Staged element: ${elementId}`, {
+      elementId,
+      layer: layerName,
+      changesetId: activeChangesetId,
+      operation: "add"
+    }, { verbose: !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);
+    isTelemetryEnabled && span && (span.recordException(error), span.setStatus({ code: 2, message: getErrorMessage(error) })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetUnstageCommand(elementId) {
+async function changesetUnstageCommand(elementId, options = {}) {
   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();
+    const model = await Model.load(options.model, { 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);
+      isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "No active changeset" })) : 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));
+    changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${activeChangesetId}' not found` })) : 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);
+      handleWarning(`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 });
+    isTelemetryEnabled && span && (span.setAttribute("unstage.found", !0), span.setAttribute("unstage.remainingChanges", updated?.getChangeCount() || 0)), handleSuccess(`Unstaged element: ${elementId}`, {
+      changesetId: activeChangesetId,
+      elementId,
+      remainingChanges: updated?.getChangeCount() || 0
+    }, { verbose: !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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
 }
-async function changesetDiscardCommand(elementId) {
+async function changesetDiscardCommand(elementId, options = {}) {
   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();
+    const model = await Model.load(options.model, { 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);
+      isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "No active changeset" })) : 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) {
+    if (changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${activeChangesetId}' not found` })) : 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);
+        handleWarning(`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)}`));
+      isTelemetryEnabled && span && span.setAttribute("discard.found", !0), handleSuccess(`Discarded changes for element: ${elementId}`, {
+        elementId
+      }, { verbose: !0 });
     } else {
       const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
       if (isTelemetryEnabled && span && span.setAttribute("cli.interactive", isInteractive), isInteractive) {
@@ -350,19 +429,23 @@ async function changesetDiscardCommand(elementId) {
           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);
+          handleSuccess("Discard cancelled", {
+            status: "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"));
+      await manager.discard(activeChangesetId), handleSuccess("Discarded all staged changes", {
+        changesetStatus: "discarded"
+      }, { verbose: !0 });
     }
-    isTelemetryEnabled && span && span.setStatus({ code: 0 }), console.log();
+    isTelemetryEnabled && span && span.setStatus({ code: 0 }), isJson() || 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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
@@ -372,7 +455,7 @@ async function changesetPreviewCommand(options) {
     "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();
+    const model = await Model.load(options.model, { 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;
@@ -425,7 +508,7 @@ async function changesetDiffCommand(options) {
     "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();
+    const model = await Model.load(options.model, { 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;
@@ -463,48 +546,52 @@ Diff: Base Model vs Staged Changes
 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();
+      const model = await Model.load(options?.model, { 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" });
+        isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "No active changeset" })) : 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));
+      changeset || (isJson() ? console.log(JSON.stringify({ status: "error", code: 2, message: `Changeset '${activeChangesetId}' not found` })) : 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 });
+        handleSuccess("No staged changes to commit", {
+          name: changeset.name,
+          changesetId: activeChangesetId,
+          stagedChanges: 0
+        }, { verbose: !0 }), 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();
+      isJson() || (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));
+        await stagingManager.clearActive(), 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 commitDetails = {
+          name: changeset.name,
+          changesetId: activeChangesetId,
+          committedCount: result.committed,
+          stagedChanges: changeCount,
+          validationPassed: result.validation.passed
+        };
+        reportCommitValidation(result, commitDetails), (result.skipped ?? 0) > 0 && (commitDetails.skipped = result.skipped, commitDetails.skippedDetails = (result.skippedDetails ?? []).slice(0, 10)), result.failed > 0 && (commitDetails.failed = result.failed);
         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.`));
+          commitDetails.unaccountedChanges = unaccounted, isJson() || 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();
+        result.driftWarning && (commitDetails.driftDetected = !0, isJson() || 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 }), handleSuccess(`Committed ${result.committed} change(s)`, commitDetails, { verbose: !0 }), isJson() || console.log();
       } catch (error) {
-        throw console.log(ansis.red(`\u2717 Commit failed and rolled back: ${getErrorMessage(error)}`)), isTelemetryEnabled && span.setAttribute("commit.rolledBack", !0), error;
+        throw isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: `Commit failed and rolled back: ${getErrorMessage(error)}` })) : 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);
+      })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), span.end(), process.exit(1);
     }
   }, {
     "commit.validate": options?.validate !== !1,
@@ -517,13 +604,17 @@ async function changesetExportCommand(changesetId, options) {
     "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 });
+    const model = await Model.load(options.model, { 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), handleSuccess(`Exported changeset to ${outputPath}`, {
+      changesetId,
+      outputPath,
+      format
+    }, { verbose: !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);
+    })), isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: getErrorMessage(error) })) : console.error(ansis.red(`Error: ${getErrorMessage(error)}`)), endSpan(span), process.exit(1);
   } finally {
     endSpan(span);
   }
@@ -534,23 +625,35 @@ async function changesetImportCommand(file, options = {}) {
     "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);
+    const model = await Model.load(options.model, { 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}`));
+      if (isJson())
+        console.log(JSON.stringify({ status: "error", code: 1, message: "Changeset is incompatible", warnings: compatibility.warnings }));
+      else {
+        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") + `
+    compatibility.baseSnapshotMatch || (options.force || (isJson() ? console.log(JSON.stringify({ status: "error", code: 1, message: "Imported changeset has base model drift" })) : 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();
+    imported.id = newId, await new StagedChangesetStorage(model.rootPath).save(imported);
+    const importDetails = {
+      changesetName: imported.name,
+      changesetId: newId,
+      additions: imported.stats?.additions || 0,
+      modifications: imported.stats?.modifications || 0,
+      deletions: imported.stats?.deletions || 0
+    };
+    compatibility.baseSnapshotMatch || (importDetails.driftDetected = !0), handleSuccess(`Imported changeset: ${imported.name}`, importDetails, { verbose: !0 }), isTelemetryEnabled && span && (span.setAttribute("changeset.id", newId), span.setStatus({ code: 0 }));
   } catch (error) {
     isTelemetryEnabled && span && (span.recordException(error), span.setStatus({
       code: 2,
@@ -562,37 +665,37 @@ async function changesetImportCommand(file, options = {}) {
 }
 function changesetCommands(program) {
   const changesetGroup = program.command("changeset").description("Manage changesets");
-  changesetGroup.command("create <name>").description("Create a new changeset").option("--description <desc>", "Changeset description").addHelpText("after", `
+  changesetGroup.command("create <name>").description("Create a new changeset").option("--model <path>", "Path to model root (contains model/manifest.yaml)").option("--description <desc>", "Changeset description").addHelpText("after", `
 Examples:
   $ dr changeset create "v1.1 migration"
   $ dr changeset create "api-refactoring" --description "Refactor API layer endpoints"`).action(async (name, options) => {
     await changesetCreateCommand(name, options);
-  }), changesetGroup.command("list").description("List all changesets").addHelpText("after", `
+  }), changesetGroup.command("list").description("List all changesets").option("--model <path>", "Path to model root (contains model/manifest.yaml)").addHelpText("after", `
 Examples:
-  $ dr changeset list`).action(async () => {
-    await changesetListCommand();
-  }), 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", `
+  $ dr changeset list`).action(async (options) => {
+    await changesetListCommand(options);
+  }), changesetGroup.command("apply <name>").description("Apply a changeset to the model").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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"
   $ 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", `
+  }), changesetGroup.command("revert <name>").description("Revert a changeset from the model").option("--model <path>", "Path to model root (contains model/manifest.yaml)").addHelpText("after", `
 Examples:
-  $ dr changeset revert "v1.1 migration"`).action(async (name) => {
-    await changesetRevertCommand(name);
-  }), changesetGroup.command("activate <name>").description("Activate a changeset for automatic change tracking").addHelpText("after", `
+  $ dr changeset revert "v1.1 migration"`).action(async (name, options) => {
+    await changesetRevertCommand(name, options);
+  }), changesetGroup.command("activate <name>").description("Activate a changeset for automatic change tracking").option("--model <path>", "Path to model root (contains model/manifest.yaml)").addHelpText("after", `
 Examples:
-  $ dr changeset activate "v1.1 migration"`).action(async (name) => {
-    await changesetActivateCommand(name);
-  }), changesetGroup.command("deactivate").description("Deactivate the currently active changeset").addHelpText("after", `
+  $ dr changeset activate "v1.1 migration"`).action(async (name, options) => {
+    await changesetActivateCommand(name, options);
+  }), changesetGroup.command("deactivate").description("Deactivate the currently active changeset").option("--model <path>", "Path to model root (contains model/manifest.yaml)").addHelpText("after", `
 Examples:
-  $ dr changeset deactivate`).action(async () => {
-    await changesetDeactivateCommand();
-  }), changesetGroup.command("status").description("Show the currently active changeset").addHelpText("after", `
+  $ dr changeset deactivate`).action(async (options) => {
+    await changesetDeactivateCommand(options);
+  }), changesetGroup.command("status").description("Show the currently active changeset").option("--model <path>", "Path to model root (contains model/manifest.yaml)").addHelpText("after", `
 Examples:
-  $ dr changeset status`).action(async () => {
-    await changesetStatusCommand();
+  $ dr changeset status`).action(async (options) => {
+    await changesetStatusCommand(options);
   }), 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
@@ -607,59 +710,70 @@ To inspect a changeset, use one of:
   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", `
+  }), changesetGroup.command("delete <name>").description("Delete a changeset permanently").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  }), changesetGroup.command("staged").description("List all staged changes in the active changeset").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  }), changesetGroup.command("stage <element-id>").description("Stage a specific element into the active changeset").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  $ dr changeset stage ux.uicomponent.login-form`).action(async (elementId, options) => {
+    await changesetExplicitStageCommand(elementId, options);
+  }), changesetGroup.command("unstage <element-id>").description("Remove specific element from staging area").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  $ dr changeset unstage api-endpoint-create-customer`).action(async (elementId, options) => {
+    await changesetUnstageCommand(elementId, options);
+  }), changesetGroup.command("discard [element-id]").description("Discard all or single staged changes").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  $ dr changeset discard api-endpoint-create-customer`).action(async (elementId, options) => {
+    await changesetDiscardCommand(elementId, options);
+  }), changesetGroup.command("preview").description("Preview the merged model state with staged changes applied").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  }), changesetGroup.command("diff").description("Show delta between base model and staged changes").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  }), changesetGroup.command("commit").description("Apply the active changeset's staged changes to the base model").allowExcessArguments(!1).option("--model <path>", "Path to model root (contains model/manifest.yaml)").addOption(new Option("--validate", "Run validation before commit (default)").hideHelp()).option("--no-validate", "Skip validation before commit (validation runs by default; only errors the changeset introduces block, errors already in the base model are reported as a count)").option("--force", "Commit despite drift warnings (does not skip validation)", !1).addHelpText("after", `
+Validation compares the model with and without the changeset. Errors the
+changeset introduces block the commit; errors the base model already had are
+not counted against it, and the output says how many there were.
+
 Examples:
   $ dr changeset commit
-  $ dr changeset commit --validate
-  $ dr changeset commit --force`).action(async (options) => {
+  $ dr changeset commit --force          # commit despite drift
+  $ dr changeset commit --no-validate    # skip validation entirely`).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", `
+  }), changesetGroup.command("export <changeset-id>").description("Export changeset to portable file").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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", `
+  }), changesetGroup.command("import <file>").description("Import changeset from file").option("--model <path>", "Path to model root (contains model/manifest.yaml)").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.command("verify [planned]").description("Compare a planned changeset with what was built (an as-built changeset, or the base model)").option("--model <path>", "Path to model root (contains model/manifest.yaml)").option("--against <changeset>", "As-built changeset (ID or name) to compare with").option("--base", "Compare with the base model").option("--no-match-by-source", "Do not match elements by shared source file").option("--json", "Output as JSON").addHelpText("after", `
+The planned changeset defaults to the active one.
+
+Examples:
+  $ dr changeset verify export-orders --against export-orders-as-built
+  $ dr changeset verify export-orders --base --json`).action(async (planned, options) => {
+    await changesetVerifyCommand(planned, options);
   }), changesetGroup.showSuggestionAfterError();
 }
 export {