refactor(global): clean up global edit command logic (#23)

* refactor(global): clean up global edit command logic

- Align control flow with other commands (before/edit/after)

- Ensure targetPath is always available for logging

- Initialize variables early in beforeEdit

- Add integration test for global edit

* fix(global): execute EDITOR directly without shell

Author: laggu

cmd/global_edit.go

@@ -0,0 +1,34 @@
+/*
+Copyright © 2026 laggu
+*/
+package cmd
+
+import (
+	"github.com/laggu/git-volume/internal/gitvolume"
+	"github.com/spf13/cobra"
+)
+
+// editCmd represents the edit command
+var editCmd = &cobra.Command{
+	Use:   "edit <file>",
+	Short: "Edit a file in the global git-volume directory",
+	Long: `Opens a file from the global git-volume directory in your default editor.
+The editor is determined by the EDITOR environment variable, defaulting to 'vi'.
+
+Examples:
+  git volume global edit config.json
+  git volume global edit secrets/api.key`,
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		gv, err := gitvolume.New(gitvolume.Options{Quiet: quiet})
+		if err != nil {
+			return err
+		}
+		return gv.GlobalEdit(args[0])
+	},
+}
+
+func init() {
+	globalCmd.AddCommand(editCmd)
+}

go.mod

@@ -10,6 +10,7 @@ require (
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect

go.sum

@@ -2,6 +2,8 @@ github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6N
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
+github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=

internal/gitvolume/edit.go

@@ -0,0 +1,87 @@
+package gitvolume
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+
+	"github.com/google/shlex"
+)
+
+// GlobalEdit opens a file from the global git-volume directory in the default editor
+func (g *GitVolume) GlobalEdit(file string) error {
+	targetPath, editor, err := g.beforeEdit(file)
+	if err == nil {
+		err = g.edit(targetPath, editor)
+	}
+
+	return g.afterEdit(targetPath, err)
+}
+
+func (g *GitVolume) beforeEdit(file string) (targetPath, editor string, err error) {
+	globalDir := g.ctx.GlobalDir
+	targetPath = file // Initialize with input file for logging in case of early error
+	editor = os.Getenv("EDITOR")
+	if editor == "" {
+		editor = "vi" // Default to vi if EDITOR is not set
+	}
+
+	// Check if global directory exists
+	if _, statErr := os.Stat(globalDir); os.IsNotExist(statErr) {
+		err = fmt.Errorf("global directory does not exist: %s", globalDir)
+		return
+	}
+
+	// Resolve target path
+	targetPath = filepath.Join(globalDir, file)
+
+	// Security: check for path traversal
+	if err = verifyPathWithinBase(targetPath, globalDir); err != nil {
+		err = fmt.Errorf("invalid file path: %w", err)
+		return
+	}
+
+	// Check if file exists
+	if _, statErr := os.Stat(targetPath); os.IsNotExist(statErr) {
+		err = fmt.Errorf("file does not exist: %s", targetPath)
+		return
+	}
+
+	return
+}
+
+func (g *GitVolume) edit(targetPath, editor string) error {
+	parts, err := shlex.Split(editor)
+	if err != nil {
+		return fmt.Errorf("failed to parse EDITOR value %q: %w", editor, err)
+	}
+	if len(parts) == 0 {
+		return fmt.Errorf("invalid EDITOR value: empty command")
+	}
+
+	cmd := exec.Command(parts[0], append(parts[1:], targetPath)...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("failed to run editor %s: %w", editor, err)
+	}
+
+	return nil
+}
+
+func (g *GitVolume) afterEdit(targetPath string, err error) error {
+	if err != nil {
+		if !g.quiet {
+			fmt.Printf("❌ Failed to edit %s: %v\n", targetPath, err)
+		}
+		return err
+	}
+
+	if !g.quiet {
+		fmt.Printf("✓ Edited %s\n", targetPath)
+	}
+	return nil
+}

internal/gitvolume/edit_test.go

@@ -0,0 +1,72 @@
+package gitvolume
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGitVolume_GlobalEdit(t *testing.T) {
+	// Setup temporary directory for global storage
+	tmpDir := t.TempDir()
+	globalDir := filepath.Join(tmpDir, "global")
+	err := os.MkdirAll(globalDir, 0755)
+	require.NoError(t, err)
+
+	// Create a dummy GitVolume instance
+	gv := &GitVolume{
+		ctx: &Context{
+			GlobalDir: globalDir,
+		},
+		quiet: true,
+	}
+
+	t.Run("Edit existing file", func(t *testing.T) {
+		// Create a file to edit
+		targetFile := filepath.Join(globalDir, "config.txt")
+		err := os.WriteFile(targetFile, []byte("initial content"), 0644)
+		require.NoError(t, err)
+
+		// Mock EDITOR to a script that modifies the file
+		// We use printf to avoid portability issues with echo -n
+		originalEditor := os.Getenv("EDITOR")
+		defer os.Setenv("EDITOR", originalEditor)
+		os.Setenv("EDITOR", "sh -c 'printf \" - edited\" >> \"$1\"' --")
+
+		err = gv.GlobalEdit("config.txt")
+		assert.NoError(t, err)
+
+		// Verify file content was updated
+		content, err := os.ReadFile(targetFile)
+		require.NoError(t, err)
+		assert.Equal(t, "initial content - edited", string(content))
+	})
+
+	t.Run("Edit non-existent file", func(t *testing.T) {
+		err := gv.GlobalEdit("missing.txt")
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "file does not exist")
+	})
+
+	t.Run("Security: Block path traversal", func(t *testing.T) {
+		err := gv.GlobalEdit("../outside.txt")
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "invalid file path")
+	})
+
+	t.Run("Global directory does not exist", func(t *testing.T) {
+		// Create a GitVolume with non-existent global dir
+		gvMissing := &GitVolume{
+			ctx: &Context{
+				GlobalDir: filepath.Join(tmpDir, "missing-global"),
+			},
+			quiet: true,
+		}
+		err := gvMissing.GlobalEdit("anything.txt")
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "global directory does not exist")
+	})
+}

test/integration.sh

@@ -233,6 +233,33 @@ else
     fail "global list missing tree connectors"
 fi
 
+# -----------------------------------------------------------------------------
+# Test: global edit
+# -----------------------------------------------------------------------------
+log "TEST" "Testing 'global edit' command..."
+
+# Setup global file if not exists
+if [[ ! -f "$TEST_DIR/.git-volume/global_source.txt" ]]; then
+    echo "GLOBAL_SECRET" > "$TEST_DIR/.git-volume/global_source.txt"
+fi
+
+# Edit file using mocked EDITOR
+# We use a simple script that appends text
+export EDITOR="sh -c 'printf \" - EDITED\" >> \"\$1\"' --"
+"$GV_BIN" global edit global_source.txt
+
+# Verify content
+CONTENT=$(cat "$TEST_DIR/.git-volume/global_source.txt")
+# Tricky: echo adds newline, printf might not depending on implementation
+# Let's just check if it contains the edited string
+if grep -q "EDITED" "$TEST_DIR/.git-volume/global_source.txt"; then
+    pass "global edit modified file correctly"
+else
+    fail "global edit failed to modify file"
+    echo "Content: $CONTENT"
+fi
+unset EDITOR
+
 # -----------------------------------------------------------------------------
 # Test: global remove
 # -----------------------------------------------------------------------------