start getting jump to work

.hof/shadow/Cli/cmd/hof/cmd/gen.go

@@ -36,7 +36,7 @@ var GenCmd = &cobra.Command{
 	Use: "gen [files...]",
 
 	Aliases: []string{
-		"g",
+		"G",
 	},
 
 	Short: "generate code, data, and config from your data models and designs",

cmd/hof/cmd/gen.go

@@ -37,7 +37,7 @@ var GenCmd = &cobra.Command{
 	Use: "gen [files...]",
 
 	Aliases: []string{
-		"g",
+		"G",
 	},
 
 	Short: "generate code, data, and config from your data models and designs",
@@ -85,4 +85,4 @@ func init() {
 	GenCmd.SetHelpFunc(thelp)
 	GenCmd.SetUsageFunc(tusage)
 
-}
+}

design/cli/cmds/hof.cue

@@ -8,7 +8,7 @@ import (
 	TBD:   "✓"
 	Name:  "gen"
 	Usage: "gen [files...]"
-	Aliases: ["g"]
+	Aliases: ["G"]
 	Short: "generate code, data, and config from your data models and designs"
 	Long: """
     generate all the things, from code to data to config...

lib/ops/jump.go

@@ -2,11 +2,134 @@ package ops
 
 import (
 	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/format"
+	"cuelang.org/go/cue/load"
+
+	"github.com/hofstadter-io/hof/cmd/hof/flags"
+	"github.com/hofstadter-io/hof/lib/cuetils"
+	"github.com/hofstadter-io/hof/lib/yagu"
 )
 
+const JUMP_FILE_NAME = "jumps.cue"
+
 func RunJumpFromArgs(args []string) error {
-	fmt.Println("lib/ops.Jump", args)
+	// fmt.Println("lib/ops.Jump", args)
+
+	jfn := JUMP_FILE_NAME
+
+	// Check our flags
+	if flags.RootResourcesDirPflag != "" {
+		rDir := flags.RootResourcesDirPflag
+		jfn = filepath.Join(rDir, JUMP_FILE_NAME)
+	} else if flags.RootLocalPflag {
+		rDir := "resources"
+		jfn = filepath.Join(rDir, JUMP_FILE_NAME)
+	} else {
+		bDir, err := os.UserConfigDir()
+		if err != nil {
+			return err
+		}
+		rDir := "resources"
+		jfn = filepath.Join(bDir, "hof", rDir, JUMP_FILE_NAME)
+	}
+	exists, _ := yagu.CheckPathExists(jfn)
+	if !exists {
+		content := `
+		package resources
+
+		jumps: {}
+		`
+		yagu.Mkdir(filepath.Dir(jfn))
+		ioutil.WriteFile(jfn, []byte(content), 0644)
+	}
+
+	var err error
+
+	entrypoints := []string {jfn}
+
+	rCRT := &cuetils.CueRuntime{
+		Entrypoints: entrypoints,
+		CueConfig: &load.Config{
+			ModuleRoot: "",
+			Module: "",
+			Package: "",
+			Dir: "",
+		},
+	}
+
+	err = rCRT.Load()
+	if err != nil {
+		return err
+	}
+
+	if len(args) == 0 {
+		bytes, err := format.Node(rCRT.CueValue.Syntax())
+		if err != nil {
+			return err
+		}
+		fmt.Printf("%s\n\n", string(bytes))
+		return nil
+	}
+
+	rest := []string{}
+	for i, arg := range args {
+		if arg == "__" {
+			rest = args[i+1:]
+			args = args[:i]
+		}
+	}
+
+	// fmt.Println("jump", args, rest)
+
+	args = append([]string{"jumps"}, args...)
+
+	V := rCRT.CueValue.Lookup(args...)
+
+	switch K := V.Kind(); K {
+
+	// we found a jump, now leap!
+	case cue.StringKind:
+		str, err := V.String()
+		if err != nil {
+			return err
+		}
+		return runJumpCommand(str, rest)
+
+	// there's more so print it
+	case cue.StructKind:
+		bytes, err := format.Node(V.Syntax())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("%s\n\n", string(bytes))
+		return nil
+
+	// TODO, case for list of strings for multiple commands to run?
+
+	// some sort of error or non-existant path
+	case cue.BottomKind:
+		return fmt.Errorf("Path not found: %q    (or it has errors)", args)
+
+	// unhandled kind
+	default:
+		return fmt.Errorf("Unsupported kind '%q' at requested path %q", K, args)
+	}
 
 	return nil
 }
 
+func runJumpCommand(cmd string, args []string) error {
+	// TODO, handle or pass in flags
+	// TODO, how to parse? is that why runtime is a thing? ('bash -c'), except we are assuming these are all bash
+	// fmt.Printf("running: %q\n", cmd)
+
+	out, err := yagu.BashTmpScriptWithArgs(cmd, args)
+	fmt.Print(out)
+	return err
+}

lib/yagu/exec.go

@@ -1,11 +1,59 @@
 package yagu
 
 import (
+	"fmt"
+	"io/ioutil"
+	"os"
 	"os/exec"
+	"strings"
 )
 
 func Bash(script string) (string, error) {
-	cmd := exec.Command("bash", "-c", script)
+	cmd := exec.Command("bash", "-p", "-c", script)
+	out, err := cmd.CombinedOutput()
+	return string(out), err
+}
+
+func BashTmpScriptWithArgs(script string, args []string) (string, error) {
+
+	// make sure we have our temp dir
+	err := Mkdir(".hof")
+	if err != nil {
+		return "", err
+	}
+
+	// create temp file
+	f, err := ioutil.TempFile(".hof", "tmp-jumps-*")
+	if err != nil {
+		return "", err
+	}
+	// and cleanup for sure
+	defer os.Remove(f.Name())
+
+	// write script
+	_, err = fmt.Fprintln(f, script)
+	if err != nil {
+		return "", err
+	}
+
+	// close
+	err = f.Close()
+	if err != nil {
+		return "", err
+	}
+
+	// make exec'd
+	err = os.Chmod(f.Name(), 0755)
+	if err != nil {
+		return "", err
+	}
+
+	// prepare args to bash invocation as a "/path/to/scripts.sh"
+	doargs := append([]string{ f.Name()}, args...)
+	dorun := strings.Join(doargs, " ")
+
+	// run script and return output / status
+	cmd := exec.Command("bash", "-p", "-c", dorun)
 	out, err := cmd.CombinedOutput()
 	return string(out), err
 }

schema/resources/hook.cue

@@ -1 +1,8 @@
 package resources
+
+#Hooks: [N=string]: #Hook & { Name: N, ... }
+#Hook: {
+	Name: string
+	Evt: string
+	Cmds: [...string]
+}

schema/resources/jump.cue

@@ -1 +1,9 @@
 package resources
+
+#Jumps: #Jump1 | #Jump2 | #Jump3 | #Jump4 | #Jump5
+
+#Jump1: [_=string]: string
+#Jump2: [_=string]: [_=string]: string
+#Jump3: [_=string]: [_=string]: [_=string]: string
+#Jump4: [_=string]: [_=string]: [_=string]: [_=string]: string
+#Jump5: [_=string]: [_=string]: [_=string]: [_=string]: [_=string]: string