Merge pull request #139 from migtools/cli-guide-rewrite

[MTA 7.3.1] CLI guide restrucures/rewrites + MTA-5731

Author: mpershina

assemblies/cli-guide/assembly_analyzing-applications-mta-cli.adoc

@@ -0,0 +1,46 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-03-17
+
+ifdef::context[:parent-context-of-analyzing-applications-mta-cli: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="analyzing-applications-mta-cli"]
+endif::[]
+ifdef::context[]
+[id="analyzing-applications-mta-cli_{context}"]
+endif::[]
+= Analyzing Java applications with {ProductShortName} command-line interface
+
+:context: analyzing-applications-mta-cli
+
+Depending on your scenario, you can use the {ProductFullName} {CLINameTitle} to perform the following actions:
+
+* Run the analysis against a single application.
+* Run the analysis against multiple applications:
+** In {ProductShortName} versions earlier than 7.1.0, you can enter a series of `--analyze` commands, each against an application and each generating a separate report. For more information, see xref:analyzing-single-app-wth-mta-cli_analyzing-applications-mta-cli[Running the {ProductShortName} {CLINameTitle} against an application].
+** In {ProductShortName} version 7.1.0 and later, you can use the `--bulk` option to analyze multiple applications at once and generate a single report. Note that this feature is a Developer Preview feature only. For more information, see xref:analyzing-multiple-apps-with-mta-cli_analyzing-applications-mta-cli[Analyzing multiple applications].
+
+[IMPORTANT]
+====
+Starting from {ProductShortName} version 7.2.0, you can run the application analysis for Java applications in the containerless mode. Note that this option is set by default and is used automatically only if all requirements are met. For more information, see xref:running-the-containerless-mta-cli_analyzing-applications-mta-cli[Analyzing an application in the containerless mode].
+
+However, if you want to analyze applications in languages other than Java or, for example, use xref:performing-transformation_cli-guide[transformation commands], you still need to use containers.
+====
+
+{ProductShortName} CLI supports running source code and binary analysis by using `analyzer-lsp`. `analyzer-lsp` is a tool that evaluates rules by using language providers.
+
+include::topics/mta-cli/proc_analyzing-single-app-with-mta-cli.adoc[leveloffset=+1]
+ 
+include::topics/mta-cli/proc_analyzing-multiple-apps-with-mta-cli.adoc[leveloffset=+1]
+
+include::topics/mta-cli/proc_running-the-containerless-mta-cli.adoc[leveloffset=+1]
+
+include::topics/mta-cli/ref_mta-cli-analyze-flags.adoc[leveloffset=+1]
+
+[role="_additional-resources"]
+
+ifdef::parent-context-of-analyzing-applications-mta-cli[:context: {parent-context-of-analyzing-applications-mta-cli}]
+ifndef::parent-context-of-analyzing-applications-mta-cli[:!context:]
+

assemblies/cli-guide/assembly_analyzing-nonjava-applications.adoc

@@ -0,0 +1,34 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-04-09
+
+ifdef::context[:parent-context-of-analyzing-multi-language-applications: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="analyzing-nonjava-applications"]
+endif::[]
+ifdef::context[]
+[id="analyzing-nonjava-applications_{context}"]
+endif::[]
+= Analyzing applications written in languages other than Java with {ProductShortName} command-line interface
+
+:context: analyzing-nonjava-applications
+
+Starting from {ProductFullName} version 7.1.0, you can run the application analysis on applications written in languages other than Java. You can perform the analysis either of the following ways:
+
+* Select a supported language provider to run the analysis for. 	
+* Overwrite the existing supported language provider with your own unsupported language provider, and then run the analysis on it.
+ 
+
+IMPORTANT: Analyzing applications written in languages other than Java is only possible in container mode. You can use the containerless CLI only for Java applications. For more information, see xref:running-the-containerless-mta-cli_analyzing-applications-mta-cli[Analyzing an application in containerless mode].
+
+
+include::topics/mta-cli/proc_analyze-selected-provider.adoc[leveloffset=+1]
+
+include::topics/mta-cli/proc_analyze-unsupported-provider.adoc[leveloffset=+1]
+
+
+ifdef::parent-context-of-analyzing-multi-language-applications[:context: {parent-context-of-analyzing-multi-language-applications}]
+ifndef::parent-context-of-analyzing-multi-language-applications[:!context:]
+

assemblies/cli-guide/assembly_generating-assets.adoc

@@ -0,0 +1,48 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-05-28
+
+ifdef::context[:parent-context-of-generating-assets: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="generating-assets"]
+endif::[]
+ifdef::context[]
+[id="generating-assets_{context}"]
+endif::[]
+= Generating platform assets for application deployment
+
+:context: generating-assets
+
+Starting from {ProductShortName} version 7.3.0, you can use the `discover` and `generate` commands in containerless mode to automatically generate the manifests needed to deploy a Cloud Foundry (CF) application in the {ocp-short}: 
+
+* Use the `discover` command to generate the discovery manifest in the YAML format from the CF application manifest. The discovery manifest preserves the specifications found in the CF manifest that define the metadata, runtime, and platform configurations.
+* Use the `generate` command to generate the deployment manifest for {ocp} deployments by using the discovery manifest. The deployment manifest is generated by using a templating engine, such as Helm, that converts the discovery manifest into a Kubernetes-native format. You can also use this command to generate non-Kubernetes manifests, such as a Dockerfile or a configuration file.
+
+:FeatureName: Generating platform assets for application deployment
+include::topics/snippets/developer-preview-admonition.adoc[]
+
+.Benefits of generating deployment assets
+
+Generating deployment assets has the following benefits:
+
+* Generating the Kubernetes and non-Kubernetes deployment manifests.   
+* Generating deployment manifests by using familiar template engines, for example, Helm, that are widely used for Kubernetes deployments.
+* Adhering to Kubernetes best practices when preparing the deployment manifest by using Helm templates.
+
+
+
+include::topics/mta-cli/proc_generating-discovery-manifest.adoc[leveloffset=+1]
+
+include::topics/mta-cli/proc_generating-deployment-manifest.adoc[leveloffset=+1]
+ 
+include::topics/mta-cli/ref_discover-generate-command-options.adoc[leveloffset=+1]
+
+include::topics/mta-cli/ref_assets-generation-example.adoc[leveloffset=+1]
+
+
+
+ifdef::parent-context-of-generating-assets[:context: {parent-context-of-generating-assets}]
+ifndef::parent-context-of-generating-assets[:!context:]
+

assemblies/cli-guide/assembly_installing-mta-cli.adoc

@@ -0,0 +1,31 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-03-14
+
+ifdef::context[:parent-context-of-installing-mta-cli: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="installing-mta-cli"]
+endif::[]
+ifdef::context[]
+[id="installing-mta-cli_{context}"]
+endif::[]
+= Installing {ProductShortName} command-line interface
+
+:context: installing-mta-cli
+
+You can install the {ProductFullName} command-line interface (CLI) on Linux, Windows, or macOS operating systems. 
+
+NOTE: You can also install the CLI for use with Docker on Windows. Note, however, that this is a Developer Preview feature only. 
+
+include::topics/mta-cli/proc_installing-cli-zip.adoc[leveloffset=+1]
+
+include::topics/mta-cli/proc_installing-mta-disconnected-environment.adoc[leveloffset=+1]
+
+include::topics/mta-cli/proc_installing-cli-for-docker.adoc[leveloffset=+1]
+
+
+ifdef::parent-context-of-installing-mta-cli[:context: {parent-context-of-installing-mta-cli}]
+ifndef::parent-context-of-installing-mta-cli[:!context:]
+

assemblies/cli-guide/assembly_performing-transformation.adoc

@@ -0,0 +1,39 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-04-08
+
+ifdef::context[:parent-context-of-performing-transformation: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="performing-transformation"]
+endif::[]
+ifdef::context[]
+[id="performing-transformation_{context}"]
+endif::[]
+= Performing a transformation with the {ProductShortName} command-line interface
+
+
+:context: performing-transformation
+
+You can use transformation to perform the following actions:
+
+* Transform Java applications source code by using the `transform openrewrite` command.
+* Convert XML rules to YAML rules by using the `transform rules` command.
+
+IMPORTANT: Performing transformation requires the container runtime to be configured. 
+ 
+
+include::topics/mta-cli/proc_transforming-application-source-code.adoc[leveloffset=+1]
+
+include::topics/mta-cli/ref_available-openrewrite-recipes.adoc[leveloffset=+1]
+
+include::topics/mta-cli/ref_openrewrite-command-options.adoc[leveloffset=+1]
+
+include::topics/mta-cli/proc_converting-xml-to-yaml.adoc[leveloffset=+1]
+
+include::topics/mta-cli/ref_rules-command-options.adoc[leveloffset=+1]
+
+ifdef::parent-context-of-performing-transformation[:context: {parent-context-of-performing-transformation}]
+ifndef::parent-context-of-performing-transformation[:!context:]
+

assemblies/cli-guide/assembly_reference-material.adoc

@@ -0,0 +1,34 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-05-28
+
+ifdef::context[:parent-context-of-reference-material: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="reference-material"]
+endif::[]
+ifdef::context[]
+[id="reference-material_{context}"]
+[appendix,id="reference-material"]
+endif::[]
+= Reference material
+
+:context: reference-material
+
+The following is information that you might find useful when using the {ProductFullName} CLI. 
+
+// {ProductShortName} Command-line Arguments
+//include::topics/mta-cli-args.adoc[leveloffset=+2]
+
+// Added in 4.3.0: list of supported Tech Tags
+include::topics/mta-cli/ref_mta-tech-tags.adoc[leveloffset=+1]
+
+// Rule Story Points
+include::assembly_rule-story-points.adoc[leveloffset=+1]
+
+
+
+ifdef::parent-context-of-reference-material[:context: {parent-context-of-reference-material}]
+ifndef::parent-context-of-reference-material[:!context:]
+

assemblies/cli-guide/assembly_reviewing-analysis-reports.adoc

@@ -16,17 +16,11 @@ endif::[]
 
 After analyzing an application, you can access an analysis report to check the details of the application migration effort.
 
-include::topics/proc_accessing-analysis-report.adoc[leveloffset=+1]
+include::topics/mta-cli/proc_accessing-analysis-report.adoc[leveloffset=+1]
 
-include::topics/ref_analysis-report-sections.adoc[leveloffset=+1]
+include::topics/mta-cli/ref_analysis-report-sections.adoc[leveloffset=+1]
 
-////
-[role="_additional-resources"]
-== Additional resources
-
-* link:https://github.com/redhat-documentation/modular-docs#modular-documentation-reference-guide[Modular Documentation Reference Guide]
-* xref:some-module_{context}[]
-////
+include::topics/mta-cli/proc_reviewing-analysis-issues-and-incidents.adoc[leveloffset=+1]
 
 ifdef::parent-context-of-reviewing-analysis-reports[:context: {parent-context-of-reviewing-analysis-reports}]
 ifndef::parent-context-of-reviewing-analysis-reports[:!context:]

assemblies/cli-guide/assembly_rule-story-points.adoc

@@ -0,0 +1,29 @@
+:_newdoc-version: 2.18.3
+:_template-generated: 2025-05-28
+
+ifdef::context[:parent-context-of-rule-story-points: {context}]
+
+:_mod-docs-content-type: ASSEMBLY
+
+ifndef::context[]
+[id="rule-story-points"]
+endif::[]
+ifdef::context[]
+[id="rule-story-points_{context}"]
+endif::[]
+= Rule story points
+
+:context: rule-story-points
+
+_Story points_ are an abstract metric commonly used in Agile software development to estimate the level of effort required to implement a feature or change.
+
+The {ProductName} uses story points to express the level of effort needed to migrate particular application constructs, and the application as a whole. It does not necessarily translate to man-hours, but the value must be consistent across tasks.
+
+include::topics/mta-cli/ref_effort-level-estimation.adoc[leveloffset=+1]
+
+include::topics/mta-cli/ref_migration-tasks-categories.adoc[leveloffset=+1]
+
+
+ifdef::parent-context-of-rule-story-points[:context: {parent-context-of-rule-story-points}]
+ifndef::parent-context-of-rule-story-points[:!context:]
+