Increase test coverage to 95% and fix merge-queue merge driver (plan 85)

.github/workflows/ci.yml

@@ -140,6 +140,8 @@ jobs:
       - uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
         with:
           go-version-file: go.mod
+      - name: Install mdsmith
+        run: go install ./cmd/mdsmith
       - name: Run tests with coverage
         run: |
           mkdir -p "$GITHUB_WORKSPACE/e2e-cover"

.github/workflows/merge-queue.yml

@@ -25,6 +25,18 @@ jobs:
           fetch-depth: 0
           token: ${{ secrets.MERGE_QUEUE_TOKEN }}
 
+      - name: Install mdsmith merge driver
+        env:
+          MDSMITH_VERSION: v0.5.0
+          MDSMITH_SHA256: 87519781aa7b5ab147d5ab1d75d4e0a1c6213479110055972a21025b537ce171
+        run: |
+          curl -fsSL "https://github.com/jeduden/mdsmith/releases/download/${MDSMITH_VERSION}/mdsmith-linux-amd64" \
+            -o "$RUNNER_TEMP/mdsmith"
+          echo "${MDSMITH_SHA256}  $RUNNER_TEMP/mdsmith" | sha256sum -c
+          chmod +x "$RUNNER_TEMP/mdsmith"
+          "$RUNNER_TEMP/mdsmith" merge-driver install
+          echo "$RUNNER_TEMP" >> "$GITHUB_PATH"
+
       - uses: jeduden/merge-queue-action@3be8077b142e4057d2fc097635d1ab6ada2bbbf5 # v0.7.1
         with:
           token: ${{ secrets.MERGE_QUEUE_TOKEN }}

.gitignore

@@ -5,3 +5,6 @@ cover.out
 /.tmp/
 docs/research/conciseness/spikes/wasm-embedded-inference/classifier.wasm
 internal/rules/concisenessscoring/wasmclassifier/classifier.wasm
+e2e-cover/
+unit.cov
+merged.cov

PLAN.md

@@ -22,7 +22,7 @@ footer: |
 | 78  | ✅     | [Query subcommand for front-matter filtering](plan/78_query-command.md)                              |
 | 83  | ✅     | [Security hardening batch](plan/83_security-hardening-batch.md)                                      |
 | 84  | ✅     | [Symlink default-deny for file discovery](plan/84_symlink-default-deny.md)                           |
-| 85  | 🔳     | [Increase test coverage to 95% by extracting shared rule helpers](plan/85_coverage-to-95-percent.md) |
+| 85  | ✅     | [Increase test coverage to 95% by extracting shared rule helpers](plan/85_coverage-to-95-percent.md) |
 | 86  | ✅     | [Markdown flavor validation](plan/86_markdown-flavor-validation.md)                                  |
 | 89  | ✅     | [TOC generator directive and MDS035 auto-fix](plan/89_toc-generator-directive.md)                    |
 | 90  | ✅     | [Isolate corpus test git config from host signing](plan/90_corpus-test-git-config-isolation.md)      |

cmd/mdsmith/e2e_test.go

@@ -1227,7 +1227,8 @@ func TestE2E_MergeDriver_Install(t *testing.T) {
 	out, err := exec.Command("git", "-C", dir, "config", "merge.mdsmith.driver").Output()
 	require.NoError(t, err, "reading git config: %v", err)
 	driver := strings.TrimSpace(string(out))
-	assert.Contains(t, driver, "mdsmith merge-driver run", "expected merge driver config with 'run', got: %s", driver)
+	assert.Contains(t, driver, "merge-driver run %O %A %B %P",
+		"expected merge driver config with run+placeholders, got: %s", driver)
 
 	// Verify .gitattributes.
 	attrs, err := os.ReadFile(filepath.Join(dir, ".gitattributes"))
@@ -1268,7 +1269,7 @@ func TestE2E_MergeDriver_Install_CustomFiles(t *testing.T) {
 	out, err := exec.Command("git", "-C", dir, "config", "merge.mdsmith.driver").Output()
 	require.NoError(t, err, "reading git config: %v", err)
 	driver := strings.TrimSpace(string(out))
-	assert.Contains(t, driver, "mdsmith merge-driver run", "expected merge driver config, got: %s", driver)
+	assert.Contains(t, driver, "merge-driver run %O %A %B %P", "expected merge driver config, got: %s", driver)
 
 	// Verify .gitattributes has custom files, not defaults.
 	attrs, err := os.ReadFile(filepath.Join(dir, ".gitattributes"))

cmd/mdsmith/mergedriver.go

@@ -395,9 +395,15 @@ func runMergeDriverInstall(args []string) int {
 }
 
 // registerMergeDriver writes the merge.mdsmith.* keys to local
-// git config.
+// git config. It uses the absolute path of the current executable
+// so the driver works regardless of whether the install directory
+// is in PATH.
 func registerMergeDriver() error {
-	driver := "mdsmith merge-driver run %O %A %B %P"
+	exe, err := resolveInstalledBinary()
+	if err != nil {
+		return fmt.Errorf("cannot locate mdsmith binary: %w", err)
+	}
+	driver := shellQuote(exe) + " merge-driver run %O %A %B %P"
 	cmds := [][]string{
 		{"git", "config", "merge.mdsmith.name",
 			"mdsmith section-aware Markdown merge"},
@@ -411,6 +417,69 @@ func registerMergeDriver() error {
 	return nil
 }
 
+// executableFunc is the function used to locate the current binary.
+// Overridden in tests to exercise the non-temporary-exe branch.
+var executableFunc = os.Executable
+
+// resolveInstalledBinary returns the absolute path to the mdsmith
+// binary to use as the git merge driver. It prefers the current
+// executable when it lives outside the OS temp directory (i.e. it
+// was installed via "go install" or a release download). When the
+// current executable is a transient "go run" binary it falls back
+// to searching PATH and then $GOPATH/bin.
+func resolveInstalledBinary() (string, error) {
+	if exe, err := executableFunc(); err == nil {
+		if !isTemporaryBinary(exe) {
+			return filepath.Clean(exe), nil
+		}
+	}
+	// Transient go-run binary — try PATH first, then $GOPATH/bin.
+	if p, err := exec.LookPath("mdsmith"); err == nil {
+		if abs, err := filepath.Abs(p); err == nil {
+			return abs, nil
+		}
+	}
+	gopath, err := goEnvPath()
+	if err == nil {
+		candidate := filepath.Join(gopath, "bin", "mdsmith")
+		if p, err := exec.LookPath(candidate); err == nil {
+			return p, nil
+		}
+	}
+	return "", fmt.Errorf(
+		"mdsmith not found in PATH or $GOPATH/bin; " +
+			"run \"go install ./cmd/mdsmith\" first",
+	)
+}
+
+// isTemporaryBinary reports whether path looks like a transient
+// binary created by "go run" (lives under the OS temp directory).
+func isTemporaryBinary(path string) bool {
+	tmp := filepath.Clean(os.TempDir())
+	path = filepath.Clean(path)
+	rel, err := filepath.Rel(tmp, path)
+	if err != nil {
+		return false
+	}
+	return rel != ".." && !strings.HasPrefix(rel, ".."+string(os.PathSeparator)) && !filepath.IsAbs(rel)
+}
+
+// shellQuote wraps s in single quotes, escaping any embedded single
+// quotes, so that it is safe to embed in a POSIX shell command such as
+// the git merge.*.driver value.
+func shellQuote(s string) string {
+	return "'" + strings.ReplaceAll(s, "'", "'\\''") + "'"
+}
+
+// goEnvPath returns the value of GOPATH by running "go env GOPATH".
+func goEnvPath() (string, error) {
+	out, err := exec.Command("go", "env", "GOPATH").Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
 // ensureGitattributes reads .gitattributes, adds any missing
 // merge driver entries for the given files, and writes it back.
 func ensureGitattributes(path string, files []string) error {

cmd/mdsmith/mergedriver_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -296,3 +297,150 @@ func TestRunMergeDriverInstall_HelpFlag_ExitsZero(t *testing.T) {
 		assert.Equal(t, 0, code)
 	})
 }
+
+// --- resolveInstalledBinary ---
+
+func TestResolveInstalledBinary_NonTemporaryExe(t *testing.T) {
+	// Override executableFunc to return a path that is NOT under os.TempDir()
+	// so isTemporaryBinary returns false.  resolveInstalledBinary should use
+	// that path directly without falling through to the PATH/GOPATH lookup.
+	fakePermanent := "/usr/local/bin-test-fake/mdsmith"
+
+	orig := executableFunc
+	t.Cleanup(func() { executableFunc = orig })
+	executableFunc = func() (string, error) { return fakePermanent, nil }
+
+	got, err := resolveInstalledBinary()
+	require.NoError(t, err)
+	assert.Equal(t, fakePermanent, got)
+}
+
+func TestResolveInstalledBinary_FromPATH(t *testing.T) {
+	// Place a fake "mdsmith" binary in a directory added to PATH.
+	// resolveInstalledBinary should find it after the temp-binary fallback.
+	dir := t.TempDir()
+	fakeBin := filepath.Join(dir, "mdsmith")
+	require.NoError(t, os.WriteFile(fakeBin, []byte("#!/bin/sh\n"), 0o755))
+
+	// Point executableFunc at a temporary path so the exe-based path is skipped.
+	orig := executableFunc
+	t.Cleanup(func() { executableFunc = orig })
+	executableFunc = func() (string, error) {
+		return filepath.Join(os.TempDir(), "fake-go-run", "mdsmith"), nil
+	}
+
+	origPath := os.Getenv("PATH")
+	t.Setenv("PATH", dir+string(os.PathListSeparator)+origPath)
+
+	got, err := resolveInstalledBinary()
+	require.NoError(t, err)
+	assert.Equal(t, fakeBin, got)
+}
+
+func TestResolveInstalledBinary_FromGopathBin(t *testing.T) {
+	// When the current exe is a transient go-run binary and "mdsmith" is
+	// not in PATH, resolveInstalledBinary must fall back to $GOPATH/bin.
+	// Limit PATH to the directory containing "go" so goEnvPath succeeds
+	// but exec.LookPath("mdsmith") fails (no other dirs to search).
+	goBin, err := exec.LookPath("go")
+	require.NoError(t, err)
+
+	gopathDir := t.TempDir()
+	gopathBinDir := filepath.Join(gopathDir, "bin")
+	require.NoError(t, os.MkdirAll(gopathBinDir, 0o755))
+	fakeBin := filepath.Join(gopathBinDir, "mdsmith")
+	require.NoError(t, os.WriteFile(fakeBin, []byte("#!/bin/sh\n"), 0o755))
+
+	orig := executableFunc
+	t.Cleanup(func() { executableFunc = orig })
+	executableFunc = func() (string, error) {
+		return filepath.Join(os.TempDir(), "fake-go-run", "mdsmith"), nil
+	}
+
+	t.Setenv("PATH", filepath.Dir(goBin))
+	t.Setenv("GOPATH", gopathDir)
+
+	got, err := resolveInstalledBinary()
+	require.NoError(t, err)
+	assert.Equal(t, fakeBin, got)
+}
+
+func TestResolveInstalledBinary_NotFound(t *testing.T) {
+	// When the exe is temporary, mdsmith is not in PATH, and GOPATH/bin has
+	// no mdsmith, resolveInstalledBinary should return an error.
+	orig := executableFunc
+	t.Cleanup(func() { executableFunc = orig })
+	executableFunc = func() (string, error) {
+		return filepath.Join(os.TempDir(), "fake-go-run", "mdsmith"), nil
+	}
+
+	// Empty PATH so LookPath("mdsmith") fails and go env GOPATH also fails.
+	t.Setenv("PATH", "")
+
+	_, err := resolveInstalledBinary()
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "mdsmith not found")
+}
+
+// --- goEnvPath ---
+
+func TestGoEnvPath_GoNotInPATH(t *testing.T) {
+	// When PATH is empty "go" cannot be found, so goEnvPath returns an error.
+	t.Setenv("PATH", "")
+	_, err := goEnvPath()
+	require.Error(t, err)
+}
+
+// --- isTemporaryBinary ---
+
+func TestIsTemporaryBinary_NonTempPath(t *testing.T) {
+	// A path outside os.TempDir() should NOT be considered temporary.
+	// Use a path that is definitely not under /tmp.
+	assert.False(t, isTemporaryBinary("/usr/local/bin/mdsmith"))
+}
+
+func TestIsTemporaryBinary_TempPath(t *testing.T) {
+	// A path under os.TempDir() IS temporary.
+	tmp := os.TempDir()
+	assert.True(t, isTemporaryBinary(filepath.Join(tmp, "go-run-123", "exe", "main")))
+}
+
+func TestIsTemporaryBinary_RelativePath_RelErrorReturnsFalse(t *testing.T) {
+	// filepath.Rel returns an error when basepath is absolute (os.TempDir
+	// is always absolute) and targpath is relative — filepath.Clean does
+	// not promote a relative path to absolute. The function must treat
+	// that as "not temporary" rather than panicking or returning true.
+	assert.False(t, isTemporaryBinary("relative/path/mdsmith"))
+}
+
+// --- registerMergeDriver ---
+
+func TestRegisterMergeDriver_BinaryNotFound_ReturnsError(t *testing.T) {
+	// When resolveInstalledBinary cannot locate a binary, registerMergeDriver
+	// must surface that error instead of writing a broken git config entry.
+	orig := executableFunc
+	t.Cleanup(func() { executableFunc = orig })
+	executableFunc = func() (string, error) {
+		return filepath.Join(os.TempDir(), "fake-go-run", "mdsmith"), nil
+	}
+	t.Setenv("PATH", "")
+
+	err := registerMergeDriver()
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "cannot locate mdsmith binary")
+}
+
+// --- shellQuote ---
+
+func TestShellQuote_NoSpecialChars(t *testing.T) {
+	assert.Equal(t, "'/usr/local/bin/mdsmith'", shellQuote("/usr/local/bin/mdsmith"))
+}
+
+func TestShellQuote_ContainsSingleQuote(t *testing.T) {
+	// A single quote in the path must be escaped as '\''.
+	assert.Equal(t, "'/path/it'\\''s/mdsmith'", shellQuote("/path/it's/mdsmith"))
+}
+
+func TestShellQuote_PathWithSpaces(t *testing.T) {
+	assert.Equal(t, "'/home/my user/bin/mdsmith'", shellQuote("/home/my user/bin/mdsmith"))
+}

internal/archetype/gensection/engine_test.go

@@ -523,3 +523,21 @@ func TestParseColumnConfig_DefaultWrap(t *testing.T) {
 		t.Errorf("expected default wrap 'truncate', got %q", cols["desc"].Wrap)
 	}
 }
+
+// =====================================================================
+// Phase 5: additional branch coverage
+// =====================================================================
+
+// TestEngine_Fix_SkipsOnInvalidYAML exercises the generateContent
+// `dir == nil || len(diags) > 0` branch in Fix.
+// When the YAML body is invalid, generateContent returns (_, false) and Fix skips.
+func TestEngine_Fix_SkipsOnInvalidYAML(t *testing.T) {
+	src := "<?mock\n: invalid : yaml ::: [\n?>\nold content\n<?/mock?>\n"
+	f := newTestFile(t, "test.md", src)
+	d := &mockDirective{content: "new content\n"}
+	e := NewEngine(d)
+	result := string(e.Fix(f))
+	// Fix should leave old content intact when YAML parsing fails.
+	assert.Contains(t, result, "old content", "expected old content preserved when YAML is invalid")
+	assert.NotContains(t, result, "new content")
+}