Add support for --output text format to ec validate input command

bringing it to feature parity with ec validate image. The text format
provides a human-readable, color-coded output that is easier to read
than JSON.

- Add text output format support with templates
- Change default output from JSON to text (matching validate image)
- Add ShowSuccesses/ShowWarnings flag support
- Add comprehensive test coverage
- Update existing tests for new API

resolves: EC-1493

Author: dheerajodha

cmd/validate/input.go

@@ -28,7 +28,6 @@ import (
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 
-	"github.com/conforma/cli/internal/applicationsnapshot"
 	"github.com/conforma/cli/internal/format"
 	"github.com/conforma/cli/internal/input"
 	"github.com/conforma/cli/internal/output"
@@ -209,12 +208,12 @@ func validateInputCmd(validate InputValidationFunc) *cobra.Command {
 				return inputs[i].FilePath > inputs[j].FilePath
 			})
 
-			report, err := input.NewReport(inputs, data.policy, manyPolicyInput)
+			report, err := input.NewReport(inputs, data.policy, manyPolicyInput, showSuccesses, showWarnings)
 			if err != nil {
 				return err
 			}
 
-			p := format.NewTargetParser(input.JSON, format.Options{ShowSuccesses: showSuccesses, ShowWarnings: showWarnings}, cmd.OutOrStdout(), utils.FS(cmd.Context()))
+			p := format.NewTargetParser(input.Text, format.Options{ShowSuccesses: showSuccesses, ShowWarnings: showWarnings}, cmd.OutOrStdout(), utils.FS(cmd.Context()))
 			if err := report.WriteAll(data.output, p); err != nil {
 				return err
 			}
@@ -235,7 +234,7 @@ func validateInputCmd(validate InputValidationFunc) *cobra.Command {
 		* git reference (github.com/user/repo//default?ref=main), or
 		* inline JSON ('{sources: {...}}')")`))
 
-	validOutputFormats := applicationsnapshot.OutputFormats
+	validOutputFormats := []string{input.JSON, input.YAML, input.Text, input.Summary}
 	cmd.Flags().StringSliceVarP(&data.output, "output", "o", data.output, hd.Doc(`
 		Write output to a file in a specific format, e.g. yaml=/tmp/output.yaml. Use empty string
 		path for stdout, e.g. yaml. May be used multiple times. Possible formats are:

cmd/validate/input_test.go

@@ -86,6 +86,7 @@ func Test_ValidateInputCmd_SuccessSingleFile(t *testing.T) {
 		"input",
 		"--file", "/input.yaml",
 		"--policy", `{"publicKey": "testkey"}`,
+		"--output", "json", // Explicitly request JSON output
 	})
 
 	utils.SetTestRekorPublicKey(t)
@@ -132,6 +133,7 @@ func Test_ValidateInputCmd_SuccessMultipleFiles(t *testing.T) {
 		"--file", "/input1.yaml",
 		"--file", "/input2.yaml",
 		"--policy", `{"name":"Default","description":"Stuff and things","sources":[{"name":"Default","policy":["/bacon/and/eggs/policy/lib","/bacon/and/eggs/policy/release"],"data":["/bacon/and/eggs/example/data"],"config":{"include":["sbom_cyclonedx"],"exclude":[]}}]}`,
+		"--output", "json", // Explicitly request JSON output
 	})
 
 	utils.SetTestRekorPublicKey(t)
@@ -359,7 +361,8 @@ func Test_ValidateInputCmd_ShowWarningsFlag(t *testing.T) {
 			require.NoError(t, afero.WriteFile(fs, "/file.yaml", []byte("some: data"), 0644))
 
 			cmd, buf := setUpValidateInputCmd(warningValidator, fs)
-			cmd.SetArgs(c.args)
+			args := append(c.args, "--output", "json") // Explicitly request JSON output
+			cmd.SetArgs(args)
 
 			utils.SetTestRekorPublicKey(t)
 			err := cmd.Execute()
@@ -394,3 +397,87 @@ func Test_ValidateInputCmd_ShowWarningsFlag(t *testing.T) {
 		})
 	}
 }
+
+func Test_ValidateInputCmd_DefaultTextOutput(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	require.NoError(t, afero.WriteFile(fs, "/input.yaml", []byte("some: data"), 0644))
+
+	// Mock validator: returns success with no violations, one success result.
+	outMock := &output.Output{
+		PolicyCheck: []evaluator.Outcome{
+			{
+				Successes: []evaluator.Result{
+					{
+						Message: "Everything looks great!",
+						Metadata: map[string]interface{}{
+							"code": "policy.nice",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	cmd, buf := setUpValidateInputCmd(mockValidate(outMock, nil), fs)
+	cmd.SetArgs([]string{
+		"input",
+		"--file", "/input.yaml",
+		"--policy", `{"publicKey": "testkey"}`,
+		// No --output flag, should default to text
+	})
+
+	utils.SetTestRekorPublicKey(t)
+	err := cmd.Execute()
+	assert.NoError(t, err)
+
+	output := buf.String()
+	// Verify text output format
+	assert.Contains(t, output, "Success: true")
+	assert.Contains(t, output, "Result: SUCCESS")
+	assert.Contains(t, output, "Violations: 0")
+	assert.Contains(t, output, "Input File: /input.yaml")
+	// Results section should not appear when there are only successes and showSuccesses=false
+	assert.NotContains(t, output, "Results:")
+}
+
+func Test_ValidateInputCmd_TextOutputWithShowSuccesses(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	require.NoError(t, afero.WriteFile(fs, "/input.yaml", []byte("some: data"), 0644))
+
+	// Mock validator: returns success with one success result.
+	outMock := &output.Output{
+		PolicyCheck: []evaluator.Outcome{
+			{
+				Successes: []evaluator.Result{
+					{
+						Message: "Everything looks great!",
+						Metadata: map[string]interface{}{
+							"code": "policy.nice",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	cmd, buf := setUpValidateInputCmd(mockValidate(outMock, nil), fs)
+	cmd.SetArgs([]string{
+		"input",
+		"--file", "/input.yaml",
+		"--policy", `{"publicKey": "testkey"}`,
+		"--show-successes",
+	})
+
+	utils.SetTestRekorPublicKey(t)
+	err := cmd.Execute()
+	assert.NoError(t, err)
+
+	output := buf.String()
+	// Verify text output format with successes shown
+	assert.Contains(t, output, "Success: true")
+	assert.Contains(t, output, "Result: SUCCESS")
+	assert.Contains(t, output, "Successes: 1")
+	assert.Contains(t, output, "Input File: /input.yaml")
+	assert.Contains(t, output, "Results:")
+	assert.Contains(t, output, "[Success] policy.nice")
+}

docs/modules/ROOT/pages/ec_validate_input.adoc

@@ -52,7 +52,7 @@ violations, include the title and the description of the failed policy
 rule. (Default: false)
 -o, --output:: Write output to a file in a specific format, e.g. yaml=/tmp/output.yaml. Use empty string
 path for stdout, e.g. yaml. May be used multiple times. Possible formats are:
-json, yaml, text, appstudio, summary, summary-markdown, junit, attestation, policy-input, vsa. In following format and file path
+json, yaml, text, summary. In following format and file path
 additional options can be provided in key=value form following the question
 mark (?) sign, for example: --output text=output.txt?show-successes=false
  (Default: [])

internal/input/report.go

@@ -18,6 +18,7 @@ package input
 
 import (
 	"bytes"
+	"embed"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -29,6 +30,7 @@ import (
 	"github.com/conforma/cli/internal/evaluator"
 	"github.com/conforma/cli/internal/format"
 	"github.com/conforma/cli/internal/policy"
+	"github.com/conforma/cli/internal/utils"
 	"github.com/conforma/cli/internal/version"
 )
 
@@ -50,6 +52,8 @@ type Report struct {
 	Data          any                              `json:"-"`
 	EffectiveTime time.Time                        `json:"effective-time"`
 	PolicyInput   [][]byte                         `json:"-"`
+	ShowSuccesses bool                             `json:"-"`
+	ShowWarnings  bool                             `json:"-"`
 }
 
 type summary struct {
@@ -87,12 +91,13 @@ type TestReport struct {
 const (
 	JSON    = "json"
 	YAML    = "yaml"
+	Text    = "text"
 	Summary = "summary"
 )
 
 // WriteReport returns a new instance of Report representing the state of
 // the filepaths provided.
-func NewReport(inputs []Input, policy policy.Policy, policyInput [][]byte) (Report, error) {
+func NewReport(inputs []Input, policy policy.Policy, policyInput [][]byte, showSuccesses bool, showWarnings bool) (Report, error) {
 	success := true
 
 	// Set the report success, remains true if all the files were successfully validated
@@ -113,13 +118,15 @@ func NewReport(inputs []Input, policy policy.Policy, policyInput [][]byte) (Repo
 		EcVersion:     info.Version,
 		EffectiveTime: policy.EffectiveTime().UTC(),
 		PolicyInput:   policyInput,
+		ShowSuccesses: showSuccesses,
+		ShowWarnings:  showWarnings,
 	}, nil
 }
 
 // WriteAll writes the report to all the given targets.
 func (r Report) WriteAll(targets []string, p format.TargetParser) (allErrors error) {
 	if len(targets) == 0 {
-		targets = append(targets, JSON)
+		targets = append(targets, Text)
 	}
 	for _, targetName := range targets {
 		target, err := p.Parse(targetName)
@@ -152,6 +159,8 @@ func (r *Report) toFormat(format string) (data []byte, err error) {
 		data, err = json.Marshal(r)
 	case YAML:
 		data, err = yaml.Marshal(r)
+	case Text:
+		data, err = generateTextReport(r)
 	case Summary:
 		data, err = json.Marshal(r.toSummary())
 	default:
@@ -206,3 +215,43 @@ func condensedMsg(results []evaluator.Result) map[string][]string {
 	}
 	return shortNames
 }
+
+//go:embed templates/*.tmpl
+var efs embed.FS
+
+func generateTextReport(r *Report) ([]byte, error) {
+	// Prepare some template input
+	// Calculate totals for the test report structure
+	var successes, failures, warnings int
+	for _, input := range r.FilePaths {
+		successes += input.SuccessCount
+		failures += len(input.Violations)
+		warnings += len(input.Warnings)
+	}
+
+	result := "SUCCESS"
+	if failures > 0 {
+		result = "FAILURE"
+	} else if warnings > 0 {
+		result = "WARNING"
+	}
+
+	testReport := TestReport{
+		Timestamp: r.created.Format(time.RFC3339),
+		Namespace: "",
+		Successes: successes,
+		Failures:  failures,
+		Warnings:  warnings,
+		Result:    result,
+	}
+
+	input := struct {
+		Report     *Report
+		TestReport TestReport
+	}{
+		Report:     r,
+		TestReport: testReport,
+	}
+
+	return utils.RenderFromTemplatesWithMain(input, "text_report.tmpl", efs)
+}