Merge pull request #2 from mutablelogic/v1

Added a cli command and OpenAI client

Author: djthorpe

Makefile

@@ -1,6 +1,5 @@
 # Paths to tools needed in dependencies
 GO := $(shell which go)
-NPM := $(shell which npm)
 
 # Build flags
 BUILD_MODULE := $(shell go list -m)
@@ -13,19 +12,13 @@ BUILD_FLAGS = -ldflags "-s -w $(BUILD_LD_FLAGS)"
 
 # Paths to locations, etc
 BUILD_DIR := "build"
-PLUGIN_DIR := $(filter-out $(wildcard plugin/*.go), $(wildcard plugin/*))
-NPM_DIR := $(wildcard npm/*)
 CMD_DIR := $(wildcard cmd/*)
 
 # Targets
-all: clean cmd npm plugins
+all: clean cmd
 
 cmd: $(CMD_DIR)
 
-plugins: $(PLUGIN_DIR)
-
-npm: $(NPM_DIR)
-
 test:
 	@${GO} mod tidy
 	@${GO} test -v ./pkg/...
@@ -34,32 +27,17 @@ $(CMD_DIR): dependencies mkdir
 	@echo Build cmd $(notdir $@)
 	@${GO} build ${BUILD_FLAGS} -o ${BUILD_DIR}/$(notdir $@) ./$@
 
-$(PLUGIN_DIR): dependencies mkdir
-	@echo Build plugin $(notdir $@)
-	@${GO} build -buildmode=plugin ${BUILD_FLAGS} -o ${BUILD_DIR}/$(notdir $@).plugin ./$@
-
-$(NPM_DIR): dependencies-npm
-	@echo Build npm $(notdir $@)
-	@cd $@ && npm install && npm run build
-
 FORCE:
 
 dependencies:
 	@test -f "${GO}" && test -x "${GO}"  || (echo "Missing go binary" && exit 1)
 
-dependencies-npm:
-	@test -f "${NPM}" && test -x "${NPM}" || (echo "Missing npm binary" && exit 1)
-
 mkdir:
 	@echo Mkdir ${BUILD_DIR}
 	@install -d ${BUILD_DIR}
 
 clean:
 	@echo Clean
 	@rm -fr $(BUILD_DIR)
-	@find ${NPM_DIR} -name dist -type d -prune -exec rm -fr {} \;
 	@${GO} mod tidy
 	@${GO} clean
-
-distclean: clean
-	@find ${NPM_DIR} -name node_modules -type d -prune -exec rm -fr {} \;

build/cli

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"fmt"
+
+	"golang.org/x/exp/maps"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Client struct {
+	ns  string
+	cmd []Command
+}
+
+type Command struct {
+	Name        string
+	Description string
+	MinArgs     int
+	MaxArgs     int
+	Fn          CommandFn
+}
+
+type CommandFn func() error
+
+///////////////////////////////////////////////////////////////////////////////
+// RUN COMMAND
+
+func Run(clients []Client, flags *Flags) error {
+	var ns = map[string][]Command{}
+	for _, client := range clients {
+		ns[client.ns] = client.cmd
+	}
+
+	if flags.NArg() == 0 {
+		return fmt.Errorf("no command specified, available commands are: %q", maps.Keys(ns))
+	}
+	cmd, exists := ns[flags.Arg(0)]
+	if !exists {
+		return fmt.Errorf("unknown command: %q, available commands are: %q", flags.Arg(0), maps.Keys(ns))
+	}
+
+	var fn CommandFn
+	for _, cmd := range cmd {
+		// Match on minimum number of arguments
+		if flags.NArg() < cmd.MinArgs {
+			continue
+		}
+		// Match on maximum number of arguments
+		if cmd.MaxArgs >= cmd.MinArgs && flags.NArg() > cmd.MaxArgs {
+			continue
+		}
+		// Match on name
+		if cmd.Name != "" && cmd.Name != flags.Arg(1) {
+			continue
+		}
+
+		// Here we have matched, so break loop
+		fn = cmd.Fn
+		break
+	}
+
+	// Run function
+	if fn == nil {
+		return fmt.Errorf("no command matched for: %q", flags.Args())
+	} else {
+		return fn()
+	}
+}

cmd/cli/command.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+	"github.com/mutablelogic/go-client/pkg/elevenlabs"
+)
+
+func ElevenlabsFlags(flags *Flags) {
+	flags.String("elevenlabs-api-key", "${ELEVENLABS_API_KEY}", "ElevenLabs API key")
+	flags.String("elevenlabs-voice", "", "Voice")
+}
+
+func ElevenlabsRegister(cmd []Client, opts []client.ClientOpt, flags *Flags) ([]Client, error) {
+	// Get API key
+	key, err := flags.GetString("elevenlabs-api-key")
+	if err != nil {
+		return nil, err
+	}
+
+	// Create client
+	elevenlabs, err := elevenlabs.New(key, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Register commands
+	cmd = append(cmd, Client{
+		ns: "elevenlabs",
+		cmd: []Command{
+			{Name: "voices", Description: "Return registered voices", MinArgs: 2, MaxArgs: 2, Fn: ElevenlabsVoices(elevenlabs, flags)},
+			{Name: "voice", Description: "Return a voice", MinArgs: 3, MaxArgs: 3, Fn: ElevenlabsVoice(elevenlabs, flags)},
+			{Name: "tts", Description: "Text-to-speech", MinArgs: 3, MaxArgs: 3, Fn: ElevenlabsTextToSpeech(elevenlabs, flags)},
+		},
+	})
+
+	// Return success
+	return cmd, nil
+}
+
+func ElevenlabsVoices(client *elevenlabs.Client, flags *Flags) CommandFn {
+	return func() error {
+		if voices, err := client.Voices(); err != nil {
+			return err
+		} else if data, err := json.MarshalIndent(voices, "", "  "); err != nil {
+			return err
+		} else {
+			fmt.Printf("Voices: %s\n", data)
+		}
+		return nil
+	}
+}
+
+func ElevenlabsVoice(client *elevenlabs.Client, flags *Flags) CommandFn {
+	return func() error {
+		if voice, err := client.Voice(flags.Arg(2)); err != nil {
+			return err
+		} else if data, err := json.MarshalIndent(voice, "", "  "); err != nil {
+			return err
+		} else {
+			fmt.Printf("%s\n", data)
+		}
+		return nil
+	}
+}
+
+func ElevenlabsTextToSpeech(client *elevenlabs.Client, flags *Flags) CommandFn {
+	return func() error {
+		// Determine the voice to use
+		voice, err := flags.GetString("elevenlabs-voice")
+		if err != nil {
+			return err
+		} else if voice == "" {
+			return fmt.Errorf("missing argument: -elevenlabs-voice")
+		}
+
+		data, err := client.TextToSpeech(flags.Arg(2), voice)
+		if err != nil {
+			return err
+		} else if _, err := os.Stdout.Write(data); err != nil {
+			return err
+		}
+		return nil
+	}
+}

cmd/cli/elevenlabs.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"flag"
+	"os"
+	"time"
+
+	"github.com/djthorpe/go-errors"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type Flags struct {
+	*flag.FlagSet
+}
+
+type FlagsRegister func(*Flags)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func NewFlags(name string, args []string, register ...FlagsRegister) (*Flags, error) {
+	flags := new(Flags)
+	flags.FlagSet = flag.NewFlagSet(name, flag.ContinueOnError)
+
+	// Register flags
+	flags.Bool("debug", false, "Enable debug logging")
+	flags.Duration("timeout", 0, "Timeout")
+	for _, fn := range register {
+		fn(flags)
+	}
+
+	// Parse command line
+	if err := flags.Parse(args); err != nil {
+		return nil, err
+	}
+
+	// Return success
+	return flags, nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (flags *Flags) IsDebug() bool {
+	return flags.Lookup("debug").Value.(flag.Getter).Get().(bool)
+}
+
+func (flags *Flags) Timeout() time.Duration {
+	return flags.Lookup("timeout").Value.(flag.Getter).Get().(time.Duration)
+}
+
+func (flags *Flags) GetString(key string) (string, error) {
+	if flag := flags.Lookup(key); flag == nil {
+		return "", errors.ErrNotFound.With(key)
+	} else {
+		return os.ExpandEnv(flag.Value.String()), nil
+	}
+}

cmd/cli/flags.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+
+	// Packages
+	"github.com/mutablelogic/go-client/pkg/client"
+	"github.com/mutablelogic/go-client/pkg/ipify"
+)
+
+func IpifyRegister(cmd []Client, opts []client.ClientOpt, flags *Flags) ([]Client, error) {
+	// Create ipify client
+	ipify, err := ipify.New(opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Register commands for router
+	cmd = append(cmd, Client{
+		ns: "ipify",
+		cmd: []Command{
+			{MinArgs: 1, MaxArgs: 1, Description: "Get external IP address", Fn: IpifyGet(ipify, flags)},
+		},
+	})
+
+	// Return success
+	return cmd, nil
+}
+
+func IpifyGet(ipify *ipify.Client, flags *Flags) CommandFn {
+	return func() error {
+		if addr, err := ipify.Get(); err != nil {
+			return err
+		} else {
+			fmt.Printf("IP Address: %s\n", addr)
+		}
+		return nil
+	}
+}

cmd/cli/ipify.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path"
+
+	"github.com/mutablelogic/go-client/pkg/client"
+)
+
+func main() {
+	name := path.Base(os.Args[0])
+	flags, err := NewFlags(name, os.Args[1:], ElevenlabsFlags)
+	if err != nil {
+		if err != flag.ErrHelp {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		} else {
+			os.Exit(0)
+		}
+	}
+
+	// Add client options
+	opts := []client.ClientOpt{}
+	if flags.IsDebug() {
+		opts = append(opts, client.OptTrace(os.Stderr, true))
+	}
+	if timeout := flags.Timeout(); timeout > 0 {
+		opts = append(opts, client.OptTimeout(timeout))
+	}
+
+	// Register commands
+	var cmd []Client
+	cmd, err = IpifyRegister(cmd, opts, flags)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	cmd, err = ElevenlabsRegister(cmd, opts, flags)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	// Run command
+	if err := Run(cmd, flags); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

cmd/cli/main.go

@@ -5,6 +5,7 @@ go 1.20
 require (
 	github.com/djthorpe/go-errors v1.0.3
 	github.com/stretchr/testify v1.8.4
+	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
 )
 
 require (

go.mod

@@ -6,6 +6,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
+golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=