Merge pull request #5 from Peefy/feat-all-subcommands

feat: add all subcommands for kcl

Author: Peefy

README-zh.md

@@ -27,7 +27,7 @@
 您可以使用 `go install` 命令安装 `kcl`。
 
 ```shell
-go install kcl-lang.io/cli@latest
+go install kcl-lang.io/cli@main
 ```
 
 ### 从 Github Release 页面手动安装
@@ -47,6 +47,11 @@ kcl --help
 
 ### 从源代码构建
 
+```shell
+git clone https://github.com/kcl-lang/cli
+cd cli && go build -o kcl
+```
+
 ## 快速开始
 
 ```shell

README.md

@@ -15,7 +15,7 @@
 
 ## Introduction
 
-`kcl` is the KCL package manager. `KCL CLI` downloads your KCL package's dependencies, compiles your KCL packages, makes packages, and uploads them to the kcl package registry.
+`kcl` is a command-line interface that includes language core features, IDE features, package management tools, community integration, and other tools.
 
 ## Installation
 
@@ -26,7 +26,7 @@
 You can download `kcl` via `go install`.
 
 ```shell
-go install kcl-lang.io/cli@latest
+go install kcl-lang.io/cli@main
 ```
 
 ### Download from GITHUB Release Page
@@ -46,6 +46,11 @@ kcl --help
 
 ### Build from Source Code
 
+```shell
+git clone https://github.com/kcl-lang/cli
+cd cli && go build -o kcl
+```
+
 ## Quick Start
 
 ```shell

cmd/clean.go

@@ -0,0 +1,69 @@
+// Copyright The KCL Authors. All rights reserved.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+	"kcl-lang.io/kcl-go/pkg/utils"
+)
+
+const (
+	cleanDesc = `
+This command cleans the kcl build cache.
+`
+	cleanExample = `  # Clean the build cache
+  kcl clean
+`
+)
+
+// NewCleanCmd returns the clean command.
+func NewCleanCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "clean",
+		Short:   "KCL clean tool",
+		Long:    cleanDesc,
+		Example: cleanExample,
+		RunE: func(_ *cobra.Command, args []string) error {
+			if len(args) == 0 {
+				args = append(args, ".")
+			}
+			pkgroot, err := utils.FindPkgRoot(args[0])
+			if err != nil {
+				fmt.Println("no cache found")
+				return err
+			}
+			cachePaths := []string{
+				filepath.Join(pkgroot, ".kclvm/cache"),
+				filepath.Join(pkgroot, "__main__/.kclvm/cache"),
+				filepath.Join(args[0], ".kclvm/cache"),
+				filepath.Join(args[0], "__main__/.kclvm/cache"),
+			}
+			for _, cachePath := range cachePaths {
+				if isDir(cachePath) {
+					if err := os.RemoveAll(cachePath); err == nil {
+						fmt.Printf("%s removed\n", cachePath)
+					} else {
+						fmt.Printf("remove %s failed\n", cachePath)
+						return err
+					}
+				}
+			}
+			return nil
+		},
+		SilenceUsage: true,
+	}
+
+	return cmd
+}
+
+func isDir(path string) bool {
+	fileInfo, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+	return fileInfo.IsDir()
+}

cmd/doc.go

@@ -0,0 +1,103 @@
+// Copyright The KCL Authors. All rights reserved.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"kcl-lang.io/kcl-go/pkg/tools/gen"
+)
+
+const (
+	docDesc = `
+This command shows documentation for KCL package or symbol.
+`
+	docExample = `  # Generate document for current package
+  kcl doc generate
+  `
+	docGenDesc = `  # Generate Markdown document for current package
+  kcl doc generate
+
+  # Generate Html document for current package
+  kcl doc generate --format html
+
+  # Generate Markdown document for specific package
+  kcl doc generate --file-path <package path>
+
+  # Generate Markdown document for specific package to a <target directory>
+  kcl doc generate --file-path <package path> --target <target directory>
+`
+	docGenExample = `  # Generate Markdown document for current package
+  kcl doc generate
+
+  # Generate Html document for current package
+  kcl doc generate --format html
+
+  # Generate Markdown document for specific package
+  kcl doc generate --file-path <package path>
+
+  # Generate Markdown document for specific package to a <target directory>
+  kcl doc generate --file-path <package path> --target <target directory>
+`
+)
+
+// NewDocCmd returns the doc command.
+func NewDocCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "doc",
+		Short:        "KCL document tool",
+		Long:         docDesc,
+		Example:      docExample,
+		SilenceUsage: true,
+	}
+
+	cmd.AddCommand(NewDocGenerateCmd())
+
+	return cmd
+}
+
+// NewDocGenerateCmd returns the doc generate command.
+func NewDocGenerateCmd() *cobra.Command {
+	o := gen.GenOpts{}
+	cmd := &cobra.Command{
+		Use:     "generate",
+		Short:   "Generates documents from code and examples",
+		Long:    docGenDesc,
+		Example: docGenExample,
+		RunE: func(*cobra.Command, []string) error {
+			genContext, err := o.ValidateComplete()
+			if err != nil {
+				fmt.Println(fmt.Errorf("generate failed: %s", err))
+				return err
+			}
+
+			err = genContext.GenDoc()
+			if err != nil {
+				fmt.Println(fmt.Errorf("generate failed: %s", err))
+				return err
+			} else {
+				fmt.Printf("Generate Complete! Check generated docs in %s\n", genContext.Target)
+				return nil
+			}
+		},
+		SilenceUsage: true,
+	}
+
+	cmd.Flags().StringVar(&o.Path, "file-path", "",
+		`Relative or absolute path to the KCL package root when running kcl-doc command from
+outside of the KCL package root directory.
+If not specified, the current work directory will be used as the KCL package root.`)
+	cmd.Flags().StringVar(&o.Format, "format", string(gen.Markdown),
+		`The document format to generate. Supported values: markdown, html, openapi.`)
+	cmd.Flags().StringVar(&o.Target, "target", "",
+		`If not specified, the current work directory will be used. A docs/ folder will be created under the target directory.`)
+	cmd.Flags().StringVar(&o.TemplateDir, "template", "",
+		`The template directory based on the KCL package root. If not specified, the built-in templates will be used.`)
+	cmd.Flags().BoolVar(&o.IgnoreDeprecated, "ignore-deprecated", false,
+		`Do not generate documentation for deprecated schemas.`)
+	cmd.Flags().BoolVar(&o.EscapeHtml, "escape-html", false,
+		`Whether to escape html symbols when the output format is markdown. Always scape when the output format is html. Default to false.`)
+
+	return cmd
+}

cmd/flags.go

@@ -0,0 +1,37 @@
+package cmd
+
+import (
+	"github.com/spf13/pflag"
+	"kcl-lang.io/cli/pkg/options"
+)
+
+func appendLangFlags(o *options.RunOptions, flags *pflag.FlagSet) {
+	flags.StringSliceVarP(&o.Arguments, "argument", "D", []string{},
+		"Specify the top-level argument")
+	flags.StringSliceVarP(&o.Settings, "setting", "Y", []string{},
+		"Specify the command line setting files")
+	flags.StringSliceVarP(&o.Overrides, "overrides", "O", []string{},
+		"Specify the configuration override path and value")
+	flags.StringSliceVarP(&o.PathSelectors, "path_selectors", "S", []string{},
+		"Specify the path selectors")
+	flags.StringSliceVarP(&o.ExternalPackages, "external", "E", []string{},
+		" Mapping of package name and path where the package is located")
+	flags.StringVarP(&o.Output, "output", "o", "",
+		"Specify the YAML/JSON output file path")
+	flags.StringVarP(&o.Tag, "tag", "t", "",
+		"Specify the tag for the OCI or Git artifact")
+	flags.StringVar(&o.Format, "format", "yaml",
+		"Specify the output format")
+	flags.BoolVarP(&o.DisableNone, "disable_none", "n", false,
+		"Disable dumping None values")
+	flags.BoolVarP(&o.StrictRangeCheck, "strict_range_check", "r", false,
+		"Do perform strict numeric range checks")
+	flags.BoolVarP(&o.Debug, "debug", "d", false,
+		"Run in debug mode")
+	flags.BoolVarP(&o.SortKeys, "sort_keys", "k", false,
+		"Sort output result keys")
+	flags.BoolVarP(&o.Vendor, "vendor", "V", false,
+		"Sort output result keys")
+	flags.BoolVar(&o.NoStyle, "no_style", false,
+		"Sort output result keys")
+}

cmd/fmt.go

@@ -0,0 +1,47 @@
+// Copyright The KCL Authors. All rights reserved.
+
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/spf13/cobra"
+	kcl "kcl-lang.io/kcl-go"
+)
+
+const (
+	fmtDesc = `
+This command formats all kcl files of the current crate using kcl-fmt.
+`
+	fmtExample = `  # Format all files in this folder recursively
+  kcl fmt ./...`
+)
+
+// NewFmtCmd returns the fmt command.
+func NewFmtCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "fmt",
+		Short:   "KCL format tool",
+		Long:    fmtDesc,
+		Example: fmtExample,
+		RunE: func(_ *cobra.Command, args []string) error {
+			var changedPaths []string
+			if len(args) == 0 {
+				args = append(args, ".")
+			}
+			for _, p := range args {
+				paths, err := kcl.FormatPath(p)
+				if err != nil {
+					return err
+				}
+				changedPaths = append(changedPaths, paths...)
+			}
+			fmt.Println(strings.Join(changedPaths, "\n"))
+			return nil
+		},
+		SilenceUsage: true,
+	}
+
+	return cmd
+}

cmd/import.go

@@ -0,0 +1,75 @@
+// Copyright The KCL Authors. All rights reserved.
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"kcl-lang.io/cli/pkg/options"
+)
+
+const (
+	importDesc = `
+This command converts other formats to KCL file.
+
+Supported conversion modes:
+- json:            convert JSON data to KCL data
+- yaml:            convert YAML data to KCL data
+- gostruct:        convert Go struct to KCL schema
+- jsonschema:      convert JSON schema to KCL schema
+- terraformschema: convert Terraform schema to KCL schema
+- openapi:         convert OpenAPI spec to KCL schema
+- crd:             convert Kubernetes CRD to KCL schema
+- auto:            automatically detect the input format
+`
+	importExample = `  # Generate KCL models from OpenAPI spec
+  kcl import -m openapi swagger.json
+
+  # Generate KCL models from Kubernetes CRD
+  kcl import -m crd crd.yaml
+
+  # Generate KCL models from JSON
+  kcl import data.json
+
+  # Generate KCL models from YAML
+  kcl import data.yaml
+
+  # Generate KCL models from JSON Schema
+  kcl import -m jsonschema schema.json
+
+  # Generate KCL models from Terraform provider schema
+  kcl import -m terraformschema schema.json
+
+  # Generate KCL models from Go structs
+  kcl import -m gostruct schema.go
+`
+)
+
+// NewImportCmd returns the import command.
+func NewImportCmd() *cobra.Command {
+	o := options.NewImportOptions()
+	cmd := &cobra.Command{
+		Use:     "import",
+		Short:   "KCL import tool",
+		Long:    importDesc,
+		Example: importExample,
+		RunE: func(_ *cobra.Command, args []string) error {
+			o.Files = args
+			return o.Run()
+		},
+		SilenceUsage: true,
+	}
+
+	cmd.Args = cobra.MinimumNArgs(1)
+	cmd.Flags().StringVarP(&o.Mode, "mode", "m", "auto",
+		"Specify the import mode. Default is mode")
+	cmd.Flags().StringVarP(&o.Output, "output", "o", "",
+		"Specify the output file path")
+	cmd.Flags().BoolVarP(&o.Force, "force", "f", false,
+		"Force overwrite output file")
+	cmd.Flags().BoolVarP(&o.SkipValidation, "skip-validation", "s", false,
+		"Skips validation of spec prior to generation")
+	cmd.Flags().StringVarP(&o.ModelPackage, "package", "p", "models",
+		"The package to save the models. Default is models")
+
+	return cmd
+}