Merge pull request #14 from satococoa/codex/fix-test-execution

Fix test execution and lint tooling

Author: satococoa

.gitignore

@@ -0,0 +1 @@
+.cache/

Makefile

@@ -1,6 +1,14 @@
 SHELL := /bin/sh
 
-GOFILES := $(shell git ls-files '*.go')
+GOFILES := $(shell git ls-files -- '*.go' | while IFS= read -r f; do [ -f "$$f" ] && printf '%s\n' "$$f"; done)
+GO_TEST_CACHE_DIR := $(CURDIR)/.cache/go-build
+GO_TEST_TMP_DIR := $(CURDIR)/.cache/go-tmp
+GO_BIN_DIR := $(CURDIR)/.cache/bin
+GOLANGCI_LINT_CACHE_DIR := $(CURDIR)/.cache/golangci-lint
+GO_RUN_ENV = GOCACHE="$(GO_TEST_CACHE_DIR)" GOTMPDIR="$(GO_TEST_TMP_DIR)"
+LINT_RUN_ENV = $(GO_RUN_ENV) GOLANGCI_LINT_CACHE="$(GOLANGCI_LINT_CACHE_DIR)"
+GOLANGCI_LINT_VERSION := v2.10.1
+GOLANGCI_LINT := $(GO_BIN_DIR)/golangci-lint-$(GOLANGCI_LINT_VERSION)
 
 .PHONY: fmt check-fmt vet lint test test-race ci
 
@@ -20,21 +28,28 @@ check-fmt:
 	fi
 
 vet:
-	go vet ./...
-
-lint:
-	@if ! command -v golangci-lint >/dev/null 2>&1; then \
-		echo "golangci-lint is not installed."; \
-		echo "Install with:"; \
-		echo "  go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.10.1"; \
-		exit 1; \
+	@mkdir -p "$(GO_TEST_CACHE_DIR)" "$(GO_TEST_TMP_DIR)"
+	$(GO_RUN_ENV) go vet ./...
+
+$(GOLANGCI_LINT):
+	@mkdir -p "$(GO_TEST_CACHE_DIR)" "$(GO_TEST_TMP_DIR)" "$(GO_BIN_DIR)" "$(GOLANGCI_LINT_CACHE_DIR)"
+	@if [ -x "$(GO_BIN_DIR)/golangci-lint" ]; then \
+		cp "$(GO_BIN_DIR)/golangci-lint" "$(GOLANGCI_LINT)"; \
+	else \
+		GOBIN="$(GO_BIN_DIR)" $(GO_RUN_ENV) go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION); \
+		cp "$(GO_BIN_DIR)/golangci-lint" "$(GOLANGCI_LINT)"; \
 	fi
-	golangci-lint run ./...
+
+lint: $(GOLANGCI_LINT)
+	@mkdir -p "$(GOLANGCI_LINT_CACHE_DIR)"
+	$(LINT_RUN_ENV) $(GOLANGCI_LINT) run
 
 test:
-	go test ./...
+	@mkdir -p "$(GO_TEST_CACHE_DIR)" "$(GO_TEST_TMP_DIR)"
+	$(GO_RUN_ENV) go test ./...
 
 test-race:
-	go test -race ./...
+	@mkdir -p "$(GO_TEST_CACHE_DIR)" "$(GO_TEST_TMP_DIR)"
+	$(GO_RUN_ENV) go test -race ./...
 
 ci: check-fmt vet lint test test-race

README.md

@@ -109,22 +109,6 @@ Shows:
   - no-op reason when include file is missing in source
 - matched / copy planned / conflicts / missing source / skipped same / errors
 
-### `git-worktreeinclude hook path`
-
-Prints the hooks directory path while respecting `core.hooksPath`.
-
-```sh
-git-worktreeinclude hook path [--absolute]
-```
-
-### `git-worktreeinclude hook print post-checkout`
-
-Prints the recommended `post-checkout` hook snippet.
-
-```sh
-git-worktreeinclude hook print post-checkout
-```
-
 ## JSON output
 
 `apply --json` emits a single JSON object to stdout.
@@ -173,7 +157,15 @@ This project does not auto-install hooks. Use manual setup.
 
 ```sh
 mkdir -p .githooks
-git-worktreeinclude hook print post-checkout > .githooks/post-checkout
+cat > .githooks/post-checkout <<'EOF'
+#!/bin/sh
+set -eu
+
+old="$1"
+if [ "$old" = "0000000000000000000000000000000000000000" ]; then
+  git worktreeinclude apply --quiet || true
+fi
+EOF
 chmod +x .githooks/post-checkout
 git config core.hooksPath .githooks
 ```
@@ -233,6 +225,7 @@ make ci
 
 CI runs on pull requests and pushes to `main` via GitHub Actions.
 `golangci-lint` is used with its default configuration (no `.golangci.yml`).
+`make lint` installs a pinned `golangci-lint` binary into `.cache/bin` on first run, so the first run needs network access to fetch the tool.
 
 ## License
 

internal/cli/cli.go

@@ -7,14 +7,12 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path/filepath"
 	"strings"
 
 	ucli "github.com/urfave/cli/v3"
 
 	"github.com/satococoa/git-worktreeinclude/internal/engine"
 	"github.com/satococoa/git-worktreeinclude/internal/exitcode"
-	"github.com/satococoa/git-worktreeinclude/internal/hooks"
 )
 
 type App struct {
@@ -62,7 +60,6 @@ func (a *App) newRootCommand() *ucli.Command {
 		Commands: []*ucli.Command{
 			a.newApplyCommand(),
 			a.newDoctorCommand(),
-			a.newHookCommand(),
 		},
 	}
 }
@@ -260,75 +257,6 @@ func (a *App) runDoctor(ctx context.Context, cmd *ucli.Command) error {
 	return nil
 }
 
-func (a *App) newHookCommand() *ucli.Command {
-	return &ucli.Command{
-		Name:         "hook",
-		Usage:        "hook helpers",
-		OnUsageError: a.onUsageError,
-		Action: func(ctx context.Context, cmd *ucli.Command) error {
-			if cmd.Args().Len() == 0 {
-				return a.onUsageError(ctx, cmd, errors.New("hook subcommand is required"), true)
-			}
-			name := cmd.Args().First()
-			if cmd.Command(name) == nil {
-				return a.onUsageError(ctx, cmd, fmt.Errorf("unknown hook subcommand: %s", name), true)
-			}
-			return nil
-		},
-		Commands: []*ucli.Command{
-			{
-				Name:         "path",
-				Usage:        "print hooks path",
-				OnUsageError: a.onUsageError,
-				Flags: []ucli.Flag{
-					&ucli.BoolFlag{Name: "absolute", Usage: "print absolute hooks path"},
-				},
-				Action: a.runHookPath,
-			},
-			{
-				Name:         "print",
-				Usage:        "print hook snippet",
-				ArgsUsage:    "post-checkout",
-				OnUsageError: a.onUsageError,
-				Action:       a.runHookPrint,
-			},
-		},
-	}
-}
-
-func (a *App) runHookPath(ctx context.Context, cmd *ucli.Command) error {
-	if cmd.Args().Len() != 0 {
-		return a.onUsageError(ctx, cmd, errors.New("hook path does not accept positional arguments"), true)
-	}
-
-	wd, err := currentWorkdir()
-	if err != nil {
-		return ucli.Exit(err.Error(), exitcode.Env)
-	}
-
-	p, err := a.engine.HookPath(ctx, wd, cmd.Bool("absolute"))
-	if err != nil {
-		return ucli.Exit(err, codedOrDefault(err, exitcode.Internal))
-	}
-
-	writeln(a.stdout, filepath.ToSlash(p))
-	return nil
-}
-
-func (a *App) runHookPrint(ctx context.Context, cmd *ucli.Command) error {
-	if cmd.Args().Len() != 1 {
-		return a.onUsageError(ctx, cmd, errors.New("hook print requires exactly one argument: post-checkout"), true)
-	}
-
-	snippet, err := hooks.PrintSnippet(cmd.Args().First())
-	if err != nil {
-		return ucli.Exit(err.Error(), exitcode.Args)
-	}
-
-	write(a.stdout, snippet)
-	return nil
-}
-
 func (a *App) handleExitError(_ context.Context, _ *ucli.Command, err error) {
 	var exitErr ucli.ExitCoder
 	if !errors.As(err, &exitErr) {
@@ -438,10 +366,6 @@ func currentWorkdir() (string, error) {
 	return wd, nil
 }
 
-func write(w io.Writer, s string) {
-	_, _ = fmt.Fprint(w, s)
-}
-
 func writeln(w io.Writer, a ...any) {
 	_, _ = fmt.Fprintln(w, a...)
 }