Address review: relative prefix, root source-dir, lint fix

- Remove includedDir != "." guard so root-level includes get
  source-dir injection (review comment #1)
- Compute display prefix relative to the catalog-owning file's
  directory via filepath.Rel, so links are correct when the
  includer is in a subdirectory (review comments #2, #3)
- Handle source-dir: "." by using RootFS directly
- Remove unused resolveGlobMatches wrapper (lint fix)
- Add tests for root-include and sibling-subdir edge cases
- Update copilot-instructions.md (mdsmith fix)

https://claude.ai/code/session_01VN3XGWEbs4qRPet8qBia59

Author: claude

.github/copilot-instructions.md

@@ -16,6 +16,7 @@ mdsmith — a Markdown linter written in Go.
 - [Plan template; see PLAN.md for status, plans live in plan/](../plan/proto.md)
 
 <?catalog
+source-dir: "."
 glob:
   - "docs/**/*.md"
   - "!docs/research/**"

internal/rules/catalog/rule.go

@@ -251,17 +251,40 @@ func splitIncludeExclude(glob string) (include, exclude []string) {
 // resolveGlobFS returns the filesystem to use for glob resolution and
 // a path prefix for display filenames. When source-dir is set (injected
 // by include expansion), globs resolve from that subdirectory of RootFS
-// and matched filenames are prefixed so links work from the including file.
+// and matched filenames are prefixed relative to the catalog-owning
+// file's directory so links work correctly.
 func resolveGlobFS(f *lint.File, params map[string]string) (globFS fs.FS, prefix string) {
 	sourceDir := params["source-dir"]
 	if sourceDir == "" || f.RootFS == nil {
 		return f.FS, ""
 	}
+
+	sourceDir = path.Clean(sourceDir)
+	fileDir := path.Clean(filepath.ToSlash(filepath.Dir(f.Path)))
+
+	// Compute prefix relative to the file's directory so display
+	// filenames produce correct links from the including file.
+	relPrefix, err := filepath.Rel(fileDir, sourceDir)
+	if err != nil {
+		return f.FS, ""
+	}
+	relPrefix = filepath.ToSlash(relPrefix)
+
+	if sourceDir == "." {
+		if relPrefix == "." {
+			return f.RootFS, ""
+		}
+		return f.RootFS, relPrefix
+	}
+
 	sub, err := fs.Sub(f.RootFS, sourceDir)
 	if err != nil {
 		return f.FS, ""
 	}
-	return sub, sourceDir
+	if relPrefix == "." {
+		return sub, ""
+	}
+	return sub, relPrefix
 }
 
 // buildCatalogEntries resolves glob matches, reads front matter, and
@@ -293,14 +316,9 @@ func buildCatalogEntries(f *lint.File, params map[string]string) []fileEntry {
 	return entries
 }
 
-// resolveGlobMatches expands include patterns, filters out exclude and
-// gitignore matches, and returns deduplicated file paths.
-func resolveGlobMatches(f *lint.File, params map[string]string) []string {
-	return resolveGlobMatchesFrom(f.FS, f, params)
-}
-
-// resolveGlobMatchesFrom is like resolveGlobMatches but uses the given
-// FS for glob resolution instead of f.FS.
+// resolveGlobMatchesFrom expands include patterns using the given FS,
+// filters out exclude and gitignore matches, and returns deduplicated
+// file paths.
 func resolveGlobMatchesFrom(globFS fs.FS, f *lint.File, params map[string]string) []string {
 	includePatterns, excludePatterns := splitIncludeExclude(params["glob"])
 	matcher, base := resolveGitignore(f, params)

internal/rules/catalog/rule_test.go

@@ -3259,3 +3259,51 @@ source-dir: "docs"
 	// The excluded file should not appear as a link in the generated content.
 	assert.NotContains(t, result, "[internal.md](docs/internal.md)")
 }
+
+func TestCatalog_SourceDirRoot(t *testing.T) {
+	// source-dir: "." means globs resolve from the project root.
+	// This happens when a subdirectory file includes a root-level file.
+	src := `<?catalog
+glob: "*.md"
+source-dir: "."
+?>
+<?/catalog?>
+`
+	mapFS := fstest.MapFS{
+		"api.md":        {Data: []byte("# API\n")},
+		"guide.md":      {Data: []byte("# Guide\n")},
+		"docs/other.md": {Data: []byte("# Other\n")},
+	}
+	f := newTestFile(t, "docs/index.md", src, mapFS)
+	f.RootFS = mapFS
+	r := &Rule{}
+	result := string(r.Fix(f))
+
+	// From docs/index.md, root files need a ../ prefix.
+	assert.Contains(t, result, "../api.md")
+	assert.Contains(t, result, "../guide.md")
+	assert.NotContains(t, result, "other.md")
+}
+
+func TestCatalog_SourceDirFromSubdirIncluder(t *testing.T) {
+	// When the catalog-owning file is in a subdirectory and source-dir
+	// points to a sibling subdirectory, the prefix should be relative.
+	src := `<?catalog
+glob: "*.md"
+source-dir: "docs/dev"
+?>
+<?/catalog?>
+`
+	mapFS := fstest.MapFS{
+		"docs/dev/api.md": {Data: []byte("# API\n")},
+		"README.md":       {Data: []byte("# Root\n")},
+	}
+	f := newTestFile(t, "docs/intro.md", src, mapFS)
+	f.RootFS = mapFS
+	r := &Rule{}
+	result := string(r.Fix(f))
+
+	// From docs/intro.md, docs/dev/api.md is at dev/api.md.
+	assert.Contains(t, result, "dev/api.md")
+	assert.NotContains(t, result, "docs/dev/api.md")
+}

internal/rules/include/rule.go

@@ -254,7 +254,7 @@ func processIncludedContent(
 	if _, wrapped := params["wrap"]; !wrapped {
 		includedDir := path.Dir(includedPath)
 		includerDir := path.Dir(filePath)
-		if includedDir != includerDir && includedDir != "." {
+		if includedDir != includerDir {
 			text = injectSourceDir(text, includedDir)
 		}
 	}

internal/rules/include/rule_test.go

@@ -733,6 +733,22 @@ func TestFix_NoSourceDirWhenSameDir(t *testing.T) {
 	assert.NotContains(t, result, "source-dir:")
 }
 
+func TestFix_InjectsSourceDirForRootInclude(t *testing.T) {
+	// When a subdir file includes a root-level file, source-dir: "."
+	// should be injected so catalog globs resolve from the project root.
+	fsys := fstest.MapFS{
+		"root-catalog.md": {Data: []byte(
+			"<?catalog\nglob: \"*.md\"\n?>\n<?/catalog?>\n",
+		)},
+	}
+	src := "<?include\nfile: ../root-catalog.md\n?>\nold\n<?/include?>\n"
+	f := newTestFile(t, "docs/index.md", src, fsys)
+	r := &Rule{}
+	result := string(r.Fix(f))
+
+	assert.Contains(t, result, `source-dir: "."`)
+}
+
 // =====================================================================
 // No FS
 // =====================================================================