Implement basic 'jmm models' command

Add basic implementation of `jmm models` command that prints artifacts
in the local store. Prints digest, maintainer, format, and size for now.

Signed-off-by: Angel Misevski <[email protected]>

Author: amisevsk

cmd/root.go

@@ -35,6 +35,14 @@ var (
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = newRootCmd()
 
+func init() {
+	rootCmd.AddCommand(build.NewCmdBuild())
+	rootCmd.AddCommand(login.NewCmdLogin())
+	rootCmd.AddCommand(pull.NewCmdPull())
+	rootCmd.AddCommand(push.NewCmdPush())
+	rootCmd.AddCommand(models.ModelsCommand())
+}
+
 func newRootCmd() *cobra.Command {
 	flags := &RootFlags{}
 	cmd := &cobra.Command{
@@ -66,6 +74,7 @@ func (f *RootFlags) ToOptions() (*RootOptions, error) {
 		ConfigHome: f.ConfigHome,
 	}, nil
 }
+
 func (o *RootOptions) Complete() error {
 	if o.ConfigHome == "" {
 		currentUser, err := user.Current()
@@ -87,11 +96,3 @@ func Execute() {
 		os.Exit(1)
 	}
 }
-
-func init() {
-	rootCmd.AddCommand(build.NewCmdBuild())
-	rootCmd.AddCommand(login.NewCmdLogin())
-	rootCmd.AddCommand(pull.NewCmdPull())
-	rootCmd.AddCommand(push.NewCmdPush())
-	rootCmd.AddCommand(models.NewCmdModels())
-}

pkg/artifact/store.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
 	"path/filepath"
 
 	_ "crypto/sha256"
@@ -17,21 +18,58 @@ import (
 )
 
 type Store struct {
-	Storage *oci.Store
+	Storage   *oci.Store
+	indexPath string
 }
 
 func NewArtifactStore(jozuhome string) *Store {
+	storeHome := filepath.Join(jozuhome, ".jozuStore")
+	indexPath := filepath.Join(storeHome, "index.json")
 
-	store, err := oci.New(filepath.Join(jozuhome, ".jozuStore"))
+	store, err := oci.New(storeHome)
 	if err != nil {
 		panic(err)
 	}
 
 	return &Store{
-		Storage: store,
+		Storage:   store,
+		indexPath: indexPath,
 	}
 }
 
+func (store *Store) SaveModel(model *Model) (*ocispec.Manifest, error) {
+	config, err := store.saveConfigFile(model.Config)
+	if err != nil {
+		return nil, err
+	}
+	for _, layer := range model.Layers {
+		_, err = store.saveContentLayer(layer)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	manifest, err := store.saveModelManifest(model, config)
+	if err != nil {
+		return nil, err
+	}
+	return manifest, nil
+}
+
+func (store *Store) ParseIndexJson() (*ocispec.Index, error) {
+	indexBytes, err := os.ReadFile(store.indexPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read index: %w", err)
+	}
+
+	index := &ocispec.Index{}
+	if err := json.Unmarshal(indexBytes, index); err != nil {
+		return nil, fmt.Errorf("failed to parse index: %w", err)
+	}
+
+	return index, nil
+}
+
 func (store *Store) saveContentLayer(layer *ModelLayer) (*ocispec.Descriptor, error) {
 	ctx := context.Background()
 
@@ -102,22 +140,3 @@ func (store *Store) saveModelManifest(model *Model, config *ocispec.Descriptor)
 	}
 	return &manifest, nil
 }
-
-func (store *Store) SaveModel(model *Model) (*ocispec.Manifest, error) {
-	config, err := store.saveConfigFile(model.Config)
-	if err != nil {
-		return nil, err
-	}
-	for _, layer := range model.Layers {
-		_, err = store.saveContentLayer(layer)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	manifest, err := store.saveModelManifest(model, config)
-	if err != nil {
-		return nil, err
-	}
-	return manifest, nil
-}

pkg/cmd/models/cmd.go

@@ -0,0 +1,59 @@
+package models
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+const (
+	shortDesc = `List models`
+	longDesc  = `List models TODO`
+)
+
+var (
+	opts *ModelsOptions
+)
+
+type ModelsOptions struct {
+	configHome string
+}
+
+func (opts *ModelsOptions) readGlobalConfig() {
+	opts.configHome = viper.GetString("config")
+}
+
+func (opts *ModelsOptions) validate() error {
+	return nil
+}
+
+// ModelsCommand represents the models command
+func ModelsCommand() *cobra.Command {
+	opts = &ModelsOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "models",
+		Short: shortDesc,
+		Long:  longDesc,
+		Run:   RunCommand(opts),
+	}
+
+	return cmd
+}
+
+func RunCommand(options *ModelsOptions) func(*cobra.Command, []string) {
+	return func(cmd *cobra.Command, args []string) {
+		options.readGlobalConfig()
+		err := options.validate()
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		err = listModels(options)
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+	}
+}

pkg/cmd/models/models.go

@@ -4,67 +4,124 @@ Copyright © 2024 Jozu.com
 package models
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
+	"io"
+	"jmm/pkg/artifact"
+	"os"
+	"text/tabwriter"
 
-	"github.com/spf13/cobra"
+	"github.com/opencontainers/go-digest"
+	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
-type ModelsFlags struct {
+const (
+	ModelsTableHeader = "DIGEST\tMAINTAINER\tMODEL FORMAT\tSIZE"
+	ModelsTableFmt    = "%s\t%s\t%s\t%s\t"
+)
+
+func listModels(opts *ModelsOptions) error {
+	store := artifact.NewArtifactStore(opts.configHome)
+	index, err := store.ParseIndexJson()
+	if err != nil {
+		return err
+	}
+
+	manifests, err := manifestsFromIndex(index, store)
+	if err != nil {
+		return err
+	}
+
+	if err := printManifestsSummary(manifests, store); err != nil {
+		return err
+	}
+
+	return nil
 }
-type ModelsOptions struct {
+
+func manifestsFromIndex(index *ocispec.Index, store *artifact.Store) (map[digest.Digest]ocispec.Manifest, error) {
+	manifests := map[digest.Digest]ocispec.Manifest{}
+	for _, manifestDesc := range index.Manifests {
+		manifestReader, err := store.Storage.Fetch(context.Background(), manifestDesc)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get manifest %s: %w", manifestDesc.Digest, err)
+		}
+		manifestBytes, err := io.ReadAll(manifestReader)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read manifest %s: %w", manifestDesc.Digest, err)
+		}
+		manifest := ocispec.Manifest{}
+		if err := json.Unmarshal(manifestBytes, &manifest); err != nil {
+			return nil, fmt.Errorf("failed to parse manifest %s: %w", manifestDesc.Digest, err)
+		}
+		manifests[manifestDesc.Digest] = manifest
+	}
+	return manifests, nil
 }
 
-// modelsCmd represents the models command
-func NewCmdModels() *cobra.Command {
-	modelsFlags := NewModelsFlags()
-
-	cmd := &cobra.Command{
-		Use:   "models",
-		Short: "A brief description of your command",
-		Long: `A longer description that spans multiple lines and likely contains examples
-	and usage of using your command. For example:
-	
-	Cobra is a CLI library for Go that empowers applications.
-	This application is a tool to generate the needed files
-	to quickly create a Cobra application.`,
-		Run: func(cmd *cobra.Command, args []string) {
-			options, err := modelsFlags.ToOptions()
-			if err != nil {
-				fmt.Println(err)
-				return
-			}
-			err = options.Validate()
-			if err != nil {
-				fmt.Println(err)
-				return
-			}
-			options.RunModels()
-			if err != nil {
-				fmt.Println(err)
-				return
-			}
-		},
+func readManifestConfig(manifest *ocispec.Manifest, store *artifact.Store) (*artifact.JozuFile, error) {
+	configReader, err := store.Storage.Fetch(context.Background(), manifest.Config)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get config: %w", err)
+	}
+	configBytes, err := io.ReadAll(configReader)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config: %w", err)
 	}
-	modelsFlags.AddFlags(cmd)
-	return cmd
+	config := &artifact.JozuFile{}
+	if err := json.Unmarshal(configBytes, config); err != nil {
+		return nil, fmt.Errorf("failed to parse config: %w", err)
+	}
+	return config, nil
 }
 
-func NewModelsFlags() *ModelsFlags {
-	return &ModelsFlags{}
+func printManifestsSummary(manifests map[digest.Digest]ocispec.Manifest, store *artifact.Store) error {
+	tw := tabwriter.NewWriter(os.Stdout, 0, 2, 3, ' ', 0)
+	fmt.Fprintln(tw, ModelsTableHeader)
+	for digest, manifest := range manifests {
+		// TODO: filter this list for manifests we're interested in (build needs to set a manifest mediaType/artifactType)
+		line, err := getManifestInfoLine(digest, &manifest, store)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintln(tw, line)
+	}
+	tw.Flush()
+	return nil
 }
 
-func (f *ModelsFlags) AddFlags(cmd *cobra.Command) {
+func getManifestInfoLine(digest digest.Digest, manifest *ocispec.Manifest, store *artifact.Store) (string, error) {
+	config, err := readManifestConfig(manifest, store)
+	if err != nil {
+		return "", err
+	}
+	var size int64
+	for _, layer := range manifest.Layers {
+		size += layer.Size
+	}
+	sizeStr := formatBytes(size)
 
+	info := fmt.Sprintf(ModelsTableFmt, digest, config.Maintainer, config.ModelFormat, sizeStr)
+	return info, nil
 }
 
-func (f *ModelsFlags) ToOptions() (*ModelsOptions, error) {
-	return &ModelsOptions{}, nil
-}
+func formatBytes(i int64) string {
+	if i == 0 {
+		return "0 B"
+	}
 
-func (o *ModelsOptions) Validate() error {
-	return nil
-}
+	suffixes := []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB"}
+	unit := float64(1024)
 
-func (o *ModelsOptions) RunModels() error {
-	return nil
+	size := float64(i)
+	for _, suffix := range suffixes {
+		if size < unit {
+			return fmt.Sprintf("%.1f %s", size, suffix)
+		}
+		size = size / unit
+	}
+
+	// Fall back to printing 1000's of PiB
+	return fmt.Sprintf("%.1f PiB", size)
 }