diff --git a/src/main/java/gov/nist/secauto/oscal/tools/cli/core/commands/AbstractResolveCommand.java b/src/main/java/gov/nist/secauto/oscal/tools/cli/core/commands/AbstractResolveCommand.java
index dec26097..5c01c5c2 100644
--- a/src/main/java/gov/nist/secauto/oscal/tools/cli/core/commands/AbstractResolveCommand.java
+++ b/src/main/java/gov/nist/secauto/oscal/tools/cli/core/commands/AbstractResolveCommand.java
@@ -27,6 +27,7 @@
 import gov.nist.secauto.oscal.lib.model.Profile;
 import gov.nist.secauto.oscal.lib.profile.resolver.ProfileResolutionException;
 import gov.nist.secauto.oscal.lib.profile.resolver.ProfileResolver;
+import gov.nist.secauto.oscal.tools.cli.core.utils.PrettyPrinter;
 
 import org.apache.commons.cli.CommandLine;
 import org.apache.commons.cli.Option;
@@ -55,6 +56,10 @@ public abstract class AbstractResolveCommand
       .desc("Generate URI references relative to this resource")
       .hasArg()
       .build();
+  private static final Option PRETTY_PRINT_OPTION = Option.builder()
+      .longOpt("pretty-print")
+      .desc("Enable pretty-printing of the output for better readability")
+      .build();
 
   @NonNull
   private static final List<Option> OPTIONS = ObjectUtils.notNull(
@@ -62,7 +67,8 @@ public abstract class AbstractResolveCommand
           MetaschemaCommands.AS_FORMAT_OPTION,
           MetaschemaCommands.TO_OPTION,
           MetaschemaCommands.OVERWRITE_OPTION,
-          RELATIVE_TO));
+          RELATIVE_TO,
+          PRETTY_PRINT_OPTION));
 
   @Override
   public String getDescription() {
@@ -198,6 +204,7 @@ protected void executeCommand(
     // validator.finalizeValidation();
 
     Format toFormat = MetaschemaCommands.getFormat(cmdLine, MetaschemaCommands.TO_OPTION);
+    boolean prettyPrint = cmdLine.hasOption(PRETTY_PRINT_OPTION);
     ISerializer<Catalog> serializer = bindingContext.newSerializer(toFormat, Catalog.class);
     try {
       if (destination == null) {
@@ -206,9 +213,52 @@ protected void executeCommand(
         serializer.serialize((Catalog) INodeItem.toValue(resolvedProfile), stdOut);
       } else {
         serializer.serialize((Catalog) INodeItem.toValue(resolvedProfile), destination);
+        if (prettyPrint) {
+          prettyPrintOutput(destination, toFormat);
+        }
       }
     } catch (IOException ex) {
       throw new CommandExecutionException(ExitCode.IO_ERROR, ex);
     }
   }
+
+  /**
+   * Pretty-print the output file based on the specified format.
+   * <p>
+   * This feature was originally contributed by Mahesh Kumar Gaddam (ermahesh) in
+   * <a href="https://github.com/usnistgov/oscal-cli/pull/295">PR #295</a>.
+   * </p>
+   *
+   * @param destination
+   *          the path to the output file
+   * @param toFormat
+   *          the format of the output file
+   * @throws CommandExecutionException
+   *           if pretty-printing fails
+   */
+  @SuppressWarnings("PMD.PreserveStackTrace")
+  private void prettyPrintOutput(@NonNull Path destination, @NonNull Format toFormat)
+      throws CommandExecutionException {
+    try {
+      switch (toFormat) {
+      case JSON:
+        PrettyPrinter.prettyPrintJson(destination.toFile());
+        break;
+      case YAML:
+        PrettyPrinter.prettyPrintYaml(destination.toFile());
+        break;
+      case XML:
+        PrettyPrinter.prettyPrintXml(destination.toFile());
+        break;
+      default:
+        // do nothing for unknown formats
+        break;
+      }
+    } catch (Exception ex) {
+      throw new CommandExecutionException(
+          ExitCode.PROCESSING_ERROR,
+          String.format("Pretty-printing failed: %s", ex.getMessage()),
+          ex);
+    }
+  }
 }
diff --git a/src/main/java/gov/nist/secauto/oscal/tools/cli/core/utils/PrettyPrinter.java b/src/main/java/gov/nist/secauto/oscal/tools/cli/core/utils/PrettyPrinter.java
new file mode 100644
index 00000000..3fbb60de
--- /dev/null
+++ b/src/main/java/gov/nist/secauto/oscal/tools/cli/core/utils/PrettyPrinter.java
@@ -0,0 +1,100 @@
+/*
+ * SPDX-FileCopyrightText: none
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+package gov.nist.secauto.oscal.tools.cli.core.utils;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+
+import net.sf.saxon.TransformerFactoryImpl;
+
+import org.w3c.dom.Document;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.xml.sax.SAXException;
+
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Utility class for pretty-printing output files in various formats.
+ * <p>
+ * This class was originally contributed by Mahesh Kumar Gaddam (ermahesh) in
+ * <a href="https://github.com/usnistgov/oscal-cli/pull/295">PR #295</a>.
+ * </p>
+ */
+public final class PrettyPrinter {
+
+  private PrettyPrinter() {
+    // prevent instantiation
+  }
+
+  /**
+   * Pretty-prints a JSON file in place.
+   *
+   * @param file
+   *          the JSON file to pretty-print
+   * @throws IOException
+   *           if an I/O error occurs
+   */
+  public static void prettyPrintJson(@NonNull File file) throws IOException {
+    ObjectMapper mapper = new ObjectMapper();
+    Object obj = mapper.readValue(file, Object.class);
+    mapper.writerWithDefaultPrettyPrinter().writeValue(file, obj);
+  }
+
+  /**
+   * Pretty-prints a YAML file in place.
+   *
+   * @param file
+   *          the YAML file to pretty-print
+   * @throws IOException
+   *           if an I/O error occurs
+   */
+  public static void prettyPrintYaml(@NonNull File file) throws IOException {
+    ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
+    Object obj = mapper.readValue(file, Object.class);
+    mapper.writerWithDefaultPrettyPrinter().writeValue(file, obj);
+  }
+
+  /**
+   * Pretty-prints an XML file in place.
+   *
+   * @param file
+   *          the XML file to pretty-print
+   * @throws IOException
+   *           if an I/O error occurs
+   * @throws ParserConfigurationException
+   *           if a DocumentBuilder cannot be created
+   * @throws SAXException
+   *           if any parse errors occur
+   * @throws TransformerException
+   *           if an error occurs during transformation
+   */
+  public static void prettyPrintXml(@NonNull File file)
+      throws IOException, ParserConfigurationException, SAXException, TransformerException {
+    Document doc = DocumentBuilderFactory.newInstance()
+        .newDocumentBuilder().parse(file);
+
+    TransformerFactoryImpl transformerFactory = new TransformerFactoryImpl();
+    Transformer transformer = transformerFactory.newTransformer();
+    transformer.setOutputProperty(OutputKeys.INDENT, "yes");
+
+    try (OutputStream out = Files.newOutputStream(file.toPath())) {
+      transformer.transform(new DOMSource(doc), new StreamResult(out));
+    }
+  }
+}
diff --git a/src/test/java/gov/nist/secauto/oscal/tools/cli/core/CLITest.java b/src/test/java/gov/nist/secauto/oscal/tools/cli/core/CLITest.java
index 4794652e..129fb740 100644
--- a/src/test/java/gov/nist/secauto/oscal/tools/cli/core/CLITest.java
+++ b/src/test/java/gov/nist/secauto/oscal/tools/cli/core/CLITest.java
@@ -10,6 +10,7 @@
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import gov.nist.secauto.metaschema.cli.processor.ExitCode;
 import gov.nist.secauto.metaschema.cli.processor.ExitStatus;
@@ -23,6 +24,7 @@
 import org.junit.jupiter.params.provider.MethodSource;
 
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -315,4 +317,100 @@ void testSystemSecurityPlanQuietlyFailing3() {
         () -> assertEquals(ExitCode.IO_ERROR, status.getExitCode()),
         () -> assertEquals(IOException.class, thrown == null ? null : thrown.getClass()));
   }
+
+  /**
+   * Tests the --pretty-print option for profile resolution with XML output.
+   * <p>
+   * This feature was originally contributed by Mahesh Kumar Gaddam (ermahesh) in
+   * <a href="https://github.com/usnistgov/oscal-cli/pull/295">PR #295</a>.
+   * </p>
+   */
+  @Test
+  void testPrettyPrintProfileResolveXml() throws IOException {
+    Path outputPath = Path.of("target/resolved_pretty_print.xml");
+    String[] args = {
+        "resolve-profile",
+        "--to=xml",
+        "--pretty-print",
+        "src/test/resources/cli/example_profile_valid.xml",
+        outputPath.toString(),
+        "--overwrite",
+        "--show-stack-trace"
+    };
+
+    ExitStatus status = CLI.runCli(args);
+    assertAll(
+        () -> assertEquals(ExitCode.OK, status.getExitCode()),
+        () -> assertTrue(Files.exists(outputPath), "Output file should exist"),
+        () -> assertPrettyPrintedOutput(outputPath));
+  }
+
+  /**
+   * Tests the --pretty-print option for profile resolution with JSON output.
+   * <p>
+   * This feature was originally contributed by Mahesh Kumar Gaddam (ermahesh) in
+   * <a href="https://github.com/usnistgov/oscal-cli/pull/295">PR #295</a>.
+   * </p>
+   */
+  @Test
+  void testPrettyPrintProfileResolveJson() throws IOException {
+    Path outputPath = Path.of("target/resolved_pretty_print.json");
+    String[] args = {
+        "resolve-profile",
+        "--to=json",
+        "--pretty-print",
+        "src/test/resources/cli/example_profile_valid.xml",
+        outputPath.toString(),
+        "--overwrite",
+        "--show-stack-trace"
+    };
+
+    ExitStatus status = CLI.runCli(args);
+    assertAll(
+        () -> assertEquals(ExitCode.OK, status.getExitCode()),
+        () -> assertTrue(Files.exists(outputPath), "Output file should exist"),
+        () -> assertPrettyPrintedOutput(outputPath));
+  }
+
+  /**
+   * Tests the --pretty-print option for profile resolution with YAML output.
+   * <p>
+   * This feature was originally contributed by Mahesh Kumar Gaddam (ermahesh) in
+   * <a href="https://github.com/usnistgov/oscal-cli/pull/295">PR #295</a>.
+   * </p>
+   */
+  @Test
+  void testPrettyPrintProfileResolveYaml() throws IOException {
+    Path outputPath = Path.of("target/resolved_pretty_print.yaml");
+    String[] args = {
+        "resolve-profile",
+        "--to=yaml",
+        "--pretty-print",
+        "src/test/resources/cli/example_profile_valid.xml",
+        outputPath.toString(),
+        "--overwrite",
+        "--show-stack-trace"
+    };
+
+    ExitStatus status = CLI.runCli(args);
+    assertAll(
+        () -> assertEquals(ExitCode.OK, status.getExitCode()),
+        () -> assertTrue(Files.exists(outputPath), "Output file should exist"),
+        () -> assertPrettyPrintedOutput(outputPath));
+  }
+
+  private void assertPrettyPrintedOutput(Path outputPath) throws IOException {
+    String content = Files.readString(outputPath, StandardCharsets.UTF_8);
+    assertAll(
+        () -> assertTrue(content != null && !content.isBlank(), "Content should not be empty"),
+        () -> {
+          // Naive pretty-print assertion: check for line breaks and indentation
+          long lineCount = content.lines().count();
+          boolean hasIndentedLines = content.lines()
+              .anyMatch(line -> line.startsWith("  ") || line.startsWith("    "));
+
+          assertTrue(lineCount > 5, "Expected multiple lines for pretty-printed output");
+          assertTrue(hasIndentedLines, "Expected indented lines in pretty-printed output");
+        });
+  }
 }
diff --git a/src/test/java/gov/nist/secauto/oscal/tools/cli/core/utils/PrettyPrinterTest.java b/src/test/java/gov/nist/secauto/oscal/tools/cli/core/utils/PrettyPrinterTest.java
new file mode 100644
index 00000000..6c52eaf7
--- /dev/null
+++ b/src/test/java/gov/nist/secauto/oscal/tools/cli/core/utils/PrettyPrinterTest.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-FileCopyrightText: none
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+package gov.nist.secauto.oscal.tools.cli.core.utils;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * Tests for the {@link PrettyPrinter} utility class.
+ * <p>
+ * This feature was originally contributed by Mahesh Kumar Gaddam (ermahesh) in
+ * <a href="https://github.com/usnistgov/oscal-cli/pull/295">PR #295</a>.
+ * </p>
+ */
+class PrettyPrinterTest {
+
+  @TempDir
+  Path tempDir;
+
+  @Test
+  void testPrettyPrintJsonValidFile() throws IOException {
+    // Create a minified JSON file
+    File jsonFile = tempDir.resolve("test.json").toFile();
+    String minifiedJson = "{\"name\":\"test\",\"value\":123,\"nested\":{\"key\":\"value\"}}";
+    Files.writeString(jsonFile.toPath(), minifiedJson, StandardCharsets.UTF_8);
+
+    // Pretty print it
+    assertDoesNotThrow(() -> PrettyPrinter.prettyPrintJson(jsonFile));
+
+    // Verify the output has proper formatting
+    String content = Files.readString(jsonFile.toPath(), StandardCharsets.UTF_8);
+    assertAll(
+        () -> assertTrue(content.contains("\n"), "Pretty-printed JSON should have line breaks"),
+        () -> assertTrue(content.contains("  ") || content.contains("\t"),
+            "Pretty-printed JSON should have indentation"));
+  }
+
+  @Test
+  void testPrettyPrintJsonInvalidFile() throws IOException {
+    // Create an invalid JSON file
+    File jsonFile = tempDir.resolve("invalid.json").toFile();
+    Files.writeString(jsonFile.toPath(), "{ invalid json }", StandardCharsets.UTF_8);
+
+    // Should throw an exception
+    assertThrows(Exception.class, () -> PrettyPrinter.prettyPrintJson(jsonFile));
+  }
+
+  @Test
+  void testPrettyPrintYamlValidFile() throws IOException {
+    // Create a YAML file
+    File yamlFile = tempDir.resolve("test.yaml").toFile();
+    String yaml = "name: test\nvalue: 123\nnested:\n  key: value";
+    Files.writeString(yamlFile.toPath(), yaml, StandardCharsets.UTF_8);
+
+    // Pretty print it
+    assertDoesNotThrow(() -> PrettyPrinter.prettyPrintYaml(yamlFile));
+
+    // Verify the file still exists and has content
+    String content = Files.readString(yamlFile.toPath(), StandardCharsets.UTF_8);
+    assertTrue(!content.isBlank(), "Pretty-printed YAML should have content");
+  }
+
+  @Test
+  void testPrettyPrintXmlValidFile() throws IOException {
+    // Create a minified XML file
+    File xmlFile = tempDir.resolve("test.xml").toFile();
+    String minifiedXml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><root><child attr=\"value\">text</child></root>";
+    Files.writeString(xmlFile.toPath(), minifiedXml, StandardCharsets.UTF_8);
+
+    // Pretty print it
+    assertDoesNotThrow(() -> PrettyPrinter.prettyPrintXml(xmlFile));
+
+    // Verify the output has proper formatting
+    String content = Files.readString(xmlFile.toPath(), StandardCharsets.UTF_8);
+    assertAll(
+        () -> assertTrue(content.contains("\n"), "Pretty-printed XML should have line breaks"),
+        () -> assertTrue(content.contains("<root>"), "Pretty-printed XML should preserve elements"));
+  }
+
+  @Test
+  void testPrettyPrintXmlInvalidFile() throws IOException {
+    // Create an invalid XML file
+    File xmlFile = tempDir.resolve("invalid.xml").toFile();
+    Files.writeString(xmlFile.toPath(), "<invalid xml", StandardCharsets.UTF_8);
+
+    // Should throw an exception
+    assertThrows(Exception.class, () -> PrettyPrinter.prettyPrintXml(xmlFile));
+  }
+
+  @Test
+  void testPrettyPrintJsonEmptyObject() throws IOException {
+    // Create an empty JSON object file
+    File jsonFile = tempDir.resolve("empty.json").toFile();
+    Files.writeString(jsonFile.toPath(), "{}", StandardCharsets.UTF_8);
+
+    // Pretty print should work without throwing
+    assertDoesNotThrow(() -> PrettyPrinter.prettyPrintJson(jsonFile));
+
+    String content = Files.readString(jsonFile.toPath(), StandardCharsets.UTF_8);
+    assertTrue(content.contains("{"), "Pretty-printed JSON should still be valid");
+  }
+
+  @Test
+  void testPrettyPrintJsonArray() throws IOException {
+    // Create a JSON array file
+    File jsonFile = tempDir.resolve("array.json").toFile();
+    String jsonArray = "[{\"id\":1},{\"id\":2},{\"id\":3}]";
+    Files.writeString(jsonFile.toPath(), jsonArray, StandardCharsets.UTF_8);
+
+    // Pretty print it
+    assertDoesNotThrow(() -> PrettyPrinter.prettyPrintJson(jsonFile));
+
+    // Verify the output has proper formatting
+    String content = Files.readString(jsonFile.toPath(), StandardCharsets.UTF_8);
+    assertTrue(content.contains("\n"), "Pretty-printed JSON array should have line breaks");
+  }
+}