Enhancement: Add environment variable to set the kpm output information level.

kpm.go

@@ -5,6 +5,8 @@ package main
 import (
 	"os"
 
+	"fmt"
+
 	"github.com/urfave/cli/v2"
 	"kcl-lang.io/kpm/pkg/client"
 	"kcl-lang.io/kpm/pkg/cmd"
@@ -16,7 +18,7 @@ func main() {
 	reporter.InitReporter()
 	kpmcli, err := client.NewKpmClient()
 	if err != nil {
-		reporter.Fatal(err)
+		kpmcli.WriteLog(fmt.Sprintf("Error: %v", err))
 	}
 	app := cli.NewApp()
 	app.Name = "kpm"

pkg/client/client.go

@@ -5,17 +5,22 @@ import (
 	"os"
 	"path/filepath"
 
+	"fmt"
+
 	remoteauth "oras.land/oras-go/v2/registry/remote/auth"
 
 	"kcl-lang.io/kpm/pkg/checker"
 	"kcl-lang.io/kpm/pkg/constants"
 	"kcl-lang.io/kpm/pkg/downloader"
 	"kcl-lang.io/kpm/pkg/env"
+	"kcl-lang.io/kpm/pkg/logger"
 	pkg "kcl-lang.io/kpm/pkg/package"
 	"kcl-lang.io/kpm/pkg/reporter"
 	"kcl-lang.io/kpm/pkg/settings"
 	"kcl-lang.io/kpm/pkg/utils"
 	"kcl-lang.io/kpm/pkg/visitor"
+
+	"strings"
 )
 
 // KpmClient is the client of kpm.
@@ -57,14 +62,23 @@ func NewKpmClient() (*KpmClient, error) {
 	)
 
 	return &KpmClient{
-		logWriter:     os.Stdout,
+		logWriter:     logger.NewLogWriter(),
 		settings:      *settings,
 		homePath:      homePath,
 		ModChecker:    ModChecker,
 		DepDownloader: &downloader.DepDownloader{},
 	}, nil
 }
 
+// WriteLog writes a log message
+func (c *KpmClient) WriteLog(message string) {
+	if strings.Contains(message, "[FATAL]") {
+		fmt.Fprintln(c.logWriter, message)
+		os.Exit(1) // Exit the program
+	}
+	c.logWriter.Write([]byte(message + "\n"))
+}
+
 // SetInsecureSkipTLSverify will set the flag of whether to skip the verification of TLS.
 func (c *KpmClient) SetInsecureSkipTLSverify(insecureSkipTLSverify bool) {
 	c.insecureSkipTLSverify = insecureSkipTLSverify

pkg/event/event.go

@@ -0,0 +1,18 @@
+package event
+
+import "kcl-lang.io/kpm/pkg/client"
+
+// KpmEvent handles diagnostic events.
+type KpmEvent struct {
+	client *client.KpmClient
+}
+
+// NewKpmEvent creates a new KpmEvent.
+func NewKpmEvent(client *client.KpmClient) *KpmEvent {
+	return &KpmEvent{client: client}
+}
+
+// Log writes a diagnostic message.
+func (e *KpmEvent) Log(message string) {
+	e.client.WriteLog(message)
+}

pkg/logger/logwriter.go

@@ -0,0 +1,38 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+)
+
+// LogWriter is a custom log writer with log level control.
+type LogWriter struct {
+	Level LogLevel
+}
+
+// LogLevel represents the log level.
+type LogLevel string
+
+const (
+	InfoLevel  LogLevel = "info"
+	DebugLevel LogLevel = "debug"
+)
+
+// NewLogWriter creates a new LogWriter with the given level.
+func NewLogWriter() *LogWriter {
+	level := os.Getenv("KPM_LOG_LEVEL")
+	if level == "" {
+		level = string(InfoLevel)
+	}
+	return &LogWriter{Level: LogLevel(level)}
+}
+
+// Write implements the io.Writer interface.
+func (lw *LogWriter) Write(p []byte) (n int, err error) {
+	if lw.Level == DebugLevel {
+		fmt.Fprintf(os.Stdout, "[DEBUG] %s", string(p))
+	} else {
+		fmt.Fprintf(os.Stdout, "[INFO] %s", string(p))
+	}
+	return len(p), nil
+}

pkg/logger/logwriter_test.go

@@ -0,0 +1,28 @@
+package logger
+
+import (
+	"os"
+	"testing"
+)
+
+func TestLogWriterInfo(t *testing.T) {
+	os.Setenv("KPM_LOG_LEVEL", "info")
+	writer := NewLogWriter()
+
+	message := "Test Info Message"
+	n, err := writer.Write([]byte(message))
+	if err != nil || n != len(message) {
+		t.Errorf("expected %d bytes written, got %d, error: %v", len(message), n, err)
+	}
+}
+
+func TestLogWriterDebug(t *testing.T) {
+	os.Setenv("KPM_LOG_LEVEL", "debug")
+	writer := NewLogWriter()
+
+	message := "Test Debug Message"
+	n, err := writer.Write([]byte(message))
+	if err != nil || n != len(message) {
+		t.Errorf("expected %d bytes written, got %d, error: %v", len(message), n, err)
+	}
+}