test: boost coverage in schema, taxonomy, shards, and find packages

- schema: GenerateRecipeSchema (basic + author/times/nutrition) and GenerateCollectionPageSchema (50% → 87%)
- taxonomy: BuildAll (basic, min_entities filter, multi-value, empty), extractValues (single, missing, enrichment), getEnrichmentOverrides (simple, missing, array path, not-array cases) → 51% → 97%
- shards/render: RenderAll tests (empty, writes shards, dry-run, unknown file) → 36% → 43%
- shards/zip: new zip_test.go covering isShardFile, matchPattern, shouldInclude (basic/dir/ext/shard/minified/large), buildExclusions (no config, custom config, invalid JSON)
- find/zip: add TestIsWorktreeClean_NonGitDir to cover previously-uncovered branch

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: greynewell

internal/archdocs/pssg/schema/jsonld_test.go

@@ -257,3 +257,103 @@ func TestComputeTotalTime(t *testing.T) {
 		}
 	}
 }
+
+// ── GenerateRecipeSchema ──────────────────────────────────────────────────────
+
+func TestGenerateRecipeSchema_Basic(t *testing.T) {
+	g := NewGenerator(
+		config.SiteConfig{BaseURL: "https://example.com", Name: "My Site"},
+		config.SchemaConfig{DatePublished: "2024-01-15"},
+	)
+	e := &entity.Entity{
+		Slug: "pasta-carbonara",
+		Fields: map[string]interface{}{
+			"title":       "Pasta Carbonara",
+			"description": "A classic Italian pasta dish.",
+		},
+	}
+	schema := g.GenerateRecipeSchema(e, "https://example.com/pasta-carbonara.html")
+	if schema["@type"] != "Recipe" {
+		t.Errorf("@type: got %v, want Recipe", schema["@type"])
+	}
+	if schema["name"] != "Pasta Carbonara" {
+		t.Errorf("name: got %v", schema["name"])
+	}
+	if schema["url"] != "https://example.com/pasta-carbonara.html" {
+		t.Errorf("url: got %v", schema["url"])
+	}
+}
+
+func TestGenerateRecipeSchema_WithAuthorAndTimes(t *testing.T) {
+	g := NewGenerator(
+		config.SiteConfig{BaseURL: "https://example.com"},
+		config.SchemaConfig{},
+	)
+	e := &entity.Entity{
+		Slug: "soup",
+		Fields: map[string]interface{}{
+			"title":           "Tomato Soup",
+			"author":          "Chef Alice",
+			"prep_time":       "PT10M",
+			"cook_time":       "PT30M",
+			"recipe_category": "Soup",
+			"cuisine":         "Italian",
+			"servings":        float64(4),
+			"calories":        float64(200),
+		},
+	}
+	schema := g.GenerateRecipeSchema(e, "https://example.com/soup.html")
+	if _, ok := schema["author"]; !ok {
+		t.Error("schema should have author")
+	}
+	if schema["prepTime"] != "PT10M" {
+		t.Errorf("prepTime: got %v", schema["prepTime"])
+	}
+	if schema["cookTime"] != "PT30M" {
+		t.Errorf("cookTime: got %v", schema["cookTime"])
+	}
+	if _, ok := schema["totalTime"]; !ok {
+		t.Error("schema should have totalTime when both prep and cook are set")
+	}
+	if schema["recipeCategory"] != "Soup" {
+		t.Errorf("recipeCategory: got %v", schema["recipeCategory"])
+	}
+	if schema["recipeCuisine"] != "Italian" {
+		t.Errorf("recipeCuisine: got %v", schema["recipeCuisine"])
+	}
+}
+
+// ── GenerateCollectionPageSchema ──────────────────────────────────────────────
+
+func TestGenerateCollectionPageSchema_Basic(t *testing.T) {
+	g := NewGenerator(config.SiteConfig{BaseURL: "https://example.com"}, config.SchemaConfig{})
+	items := []ItemListEntry{
+		{Name: "Pasta", URL: "https://example.com/pasta.html"},
+		{Name: "Soup", URL: "https://example.com/soup.html"},
+	}
+	schema := g.GenerateCollectionPageSchema("Italian Recipes", "Best Italian food", "https://example.com/italian/", items, "https://example.com/img.png")
+	if schema["@type"] != "CollectionPage" {
+		t.Errorf("@type: got %v, want CollectionPage", schema["@type"])
+	}
+	if schema["name"] != "Italian Recipes" {
+		t.Errorf("name: got %v", schema["name"])
+	}
+	if schema["image"] != "https://example.com/img.png" {
+		t.Errorf("image: got %v", schema["image"])
+	}
+	main, ok := schema["mainEntity"].(map[string]interface{})
+	if !ok {
+		t.Fatal("mainEntity should be a map")
+	}
+	if main["numberOfItems"] != 2 {
+		t.Errorf("numberOfItems: got %v, want 2", main["numberOfItems"])
+	}
+}
+
+func TestGenerateCollectionPageSchema_NoImage(t *testing.T) {
+	g := NewGenerator(config.SiteConfig{}, config.SchemaConfig{})
+	schema := g.GenerateCollectionPageSchema("Name", "Desc", "https://example.com/", nil, "")
+	if _, ok := schema["image"]; ok {
+		t.Error("should not set image when imageURL is empty")
+	}
+}

internal/archdocs/pssg/taxonomy/taxonomy_test.go

@@ -3,9 +3,153 @@ package taxonomy
 import (
 	"testing"
 
+	"github.com/supermodeltools/cli/internal/archdocs/pssg/config"
 	"github.com/supermodeltools/cli/internal/archdocs/pssg/entity"
 )
 
+// ── BuildAll / buildOne / extractValues ───────────────────────────────────────
+
+func TestBuildAll_Basic(t *testing.T) {
+	entities := []*entity.Entity{
+		{Slug: "pasta", Fields: map[string]interface{}{"cuisine": "Italian"}},
+		{Slug: "ramen", Fields: map[string]interface{}{"cuisine": "Japanese"}},
+		{Slug: "sushi", Fields: map[string]interface{}{"cuisine": "Japanese"}},
+	}
+	tc := config.TaxonomyConfig{Name: "cuisine", Field: "cuisine", MinEntities: 1}
+	taxes := BuildAll(entities, []config.TaxonomyConfig{tc}, nil)
+
+	if len(taxes) != 1 {
+		t.Fatalf("expected 1 taxonomy, got %d", len(taxes))
+	}
+	tax := taxes[0]
+	if tax.Name != "cuisine" {
+		t.Errorf("tax name: got %q, want cuisine", tax.Name)
+	}
+	// 2 unique cuisines: Italian (1 entity), Japanese (2 entities)
+	if len(tax.Entries) != 2 {
+		t.Errorf("expected 2 entries, got %d", len(tax.Entries))
+	}
+}
+
+func TestBuildAll_MinEntitiesFilter(t *testing.T) {
+	entities := []*entity.Entity{
+		{Slug: "pasta", Fields: map[string]interface{}{"cuisine": "Italian"}},
+		{Slug: "ramen", Fields: map[string]interface{}{"cuisine": "Japanese"}},
+		{Slug: "sushi", Fields: map[string]interface{}{"cuisine": "Japanese"}},
+	}
+	tc := config.TaxonomyConfig{Name: "cuisine", Field: "cuisine", MinEntities: 2}
+	taxes := BuildAll(entities, []config.TaxonomyConfig{tc}, nil)
+
+	// Only Japanese (2 entities) passes the min_entities=2 filter.
+	if len(taxes[0].Entries) != 1 {
+		t.Errorf("expected 1 entry (only Japanese), got %d", len(taxes[0].Entries))
+	}
+	if taxes[0].Entries[0].Name != "Japanese" {
+		t.Errorf("expected Japanese, got %q", taxes[0].Entries[0].Name)
+	}
+}
+
+func TestBuildAll_MultiValue(t *testing.T) {
+	entities := []*entity.Entity{
+		{Slug: "pasta", Fields: map[string]interface{}{"tags": []string{"italian", "pasta"}}},
+		{Slug: "pizza", Fields: map[string]interface{}{"tags": []string{"italian", "baked"}}},
+	}
+	tc := config.TaxonomyConfig{Name: "tags", Field: "tags", MultiValue: true, MinEntities: 1}
+	taxes := BuildAll(entities, []config.TaxonomyConfig{tc}, nil)
+
+	// Should have 3 unique tags: italian (2), pasta (1), baked (1)
+	if len(taxes[0].Entries) != 3 {
+		t.Errorf("multi-value: expected 3 entries, got %d: %v", len(taxes[0].Entries), taxes[0].Entries)
+	}
+}
+
+func TestBuildAll_Empty(t *testing.T) {
+	taxes := BuildAll(nil, nil, nil)
+	if taxes != nil {
+		t.Errorf("nil input: want nil, got %v", taxes)
+	}
+}
+
+func TestExtractValues_SingleValue(t *testing.T) {
+	e := &entity.Entity{Fields: map[string]interface{}{"cuisine": "Italian"}}
+	tc := config.TaxonomyConfig{Field: "cuisine"}
+	got := extractValues(e, tc, nil)
+	if len(got) != 1 || got[0] != "Italian" {
+		t.Errorf("single value: got %v, want [Italian]", got)
+	}
+}
+
+func TestExtractValues_Missing(t *testing.T) {
+	e := &entity.Entity{Fields: map[string]interface{}{}}
+	tc := config.TaxonomyConfig{Field: "cuisine"}
+	if got := extractValues(e, tc, nil); got != nil {
+		t.Errorf("missing field: want nil, got %v", got)
+	}
+}
+
+func TestExtractValues_EnrichmentOverride(t *testing.T) {
+	e := &entity.Entity{
+		Slug:   "pasta",
+		Fields: map[string]interface{}{"cuisine": "Italian"},
+	}
+	tc := config.TaxonomyConfig{
+		Field:                   "cuisine",
+		EnrichmentOverrideField: "override_cuisine",
+	}
+	enrichment := map[string]map[string]interface{}{
+		"pasta": {"override_cuisine": "Mediterranean"},
+	}
+	got := extractValues(e, tc, enrichment)
+	if len(got) != 1 || got[0] != "Mediterranean" {
+		t.Errorf("enrichment override: got %v, want [Mediterranean]", got)
+	}
+}
+
+// ── getEnrichmentOverrides ────────────────────────────────────────────────────
+
+func TestGetEnrichmentOverrides_SimpleField(t *testing.T) {
+	data := map[string]interface{}{"cuisine": "Italian"}
+	got := getEnrichmentOverrides(data, "cuisine")
+	if len(got) != 1 || got[0] != "Italian" {
+		t.Errorf("simple field: got %v, want [Italian]", got)
+	}
+}
+
+func TestGetEnrichmentOverrides_SimpleField_Missing(t *testing.T) {
+	data := map[string]interface{}{}
+	if got := getEnrichmentOverrides(data, "cuisine"); got != nil {
+		t.Errorf("missing field: want nil, got %v", got)
+	}
+}
+
+func TestGetEnrichmentOverrides_ArrayPath(t *testing.T) {
+	data := map[string]interface{}{
+		"ingredients": []interface{}{
+			map[string]interface{}{"normalizedName": "tomato"},
+			map[string]interface{}{"normalizedName": "basil"},
+			map[string]interface{}{"normalizedName": ""}, // empty — should be skipped
+		},
+	}
+	got := getEnrichmentOverrides(data, "ingredients[].normalizedName")
+	if len(got) != 2 || got[0] != "tomato" || got[1] != "basil" {
+		t.Errorf("array path: got %v, want [tomato basil]", got)
+	}
+}
+
+func TestGetEnrichmentOverrides_ArrayField_Missing(t *testing.T) {
+	data := map[string]interface{}{}
+	if got := getEnrichmentOverrides(data, "ingredients[].name"); got != nil {
+		t.Errorf("missing array: want nil, got %v", got)
+	}
+}
+
+func TestGetEnrichmentOverrides_ArrayField_NotArray(t *testing.T) {
+	data := map[string]interface{}{"ingredients": "not-an-array"}
+	if got := getEnrichmentOverrides(data, "ingredients[].name"); got != nil {
+		t.Errorf("non-array: want nil, got %v", got)
+	}
+}
+
 // TestGroupByLetterASCII verifies that ASCII entry names are grouped correctly.
 func TestGroupByLetterASCII(t *testing.T) {
 	entries := []Entry{

internal/find/zip_test.go

@@ -14,6 +14,12 @@ func TestIsGitRepo_NotGit(t *testing.T) {
 	}
 }
 
+func TestIsWorktreeClean_NonGitDir(t *testing.T) {
+	if isWorktreeClean(t.TempDir()) {
+		t.Error("non-git dir should not be considered clean")
+	}
+}
+
 func TestWalkZip_IncludesFiles(t *testing.T) {
 	src := t.TempDir()
 	if err := os.WriteFile(filepath.Join(src, "main.go"), []byte("package main"), 0600); err != nil {

internal/shards/render_test.go

@@ -471,6 +471,81 @@ func TestUpdateGitignore_NoTrailingNewlineHandled(t *testing.T) {
 	}
 }
 
+// ── RenderAll ─────────────────────────────────────────────────────────────────
+
+func TestRenderAll_EmptyFiles(t *testing.T) {
+	dir := t.TempDir()
+	c := makeRenderCache(shardIR(nil, nil))
+	n, err := RenderAll(dir, c, nil, false)
+	if err != nil {
+		t.Fatalf("RenderAll(empty): %v", err)
+	}
+	if n != 0 {
+		t.Errorf("expected 0 written, got %d", n)
+	}
+}
+
+func TestRenderAll_WritesShards(t *testing.T) {
+	ir := shardIR(
+		[]api.Node{
+			{ID: "fa", Labels: []string{"File"}, Properties: map[string]any{"filePath": "src/a.go"}},
+			{ID: "fb", Labels: []string{"File"}, Properties: map[string]any{"filePath": "src/b.go"}},
+			{ID: "fn1", Labels: []string{"Function"}, Properties: map[string]any{"name": "doWork", "filePath": "src/a.go"}},
+		},
+		[]api.Relationship{
+			{ID: "r1", Type: "imports", StartNode: "fa", EndNode: "fb"},
+		},
+	)
+	dir := t.TempDir()
+	c := makeRenderCache(ir)
+	n, err := RenderAll(dir, c, []string{"src/a.go"}, false)
+	if err != nil {
+		t.Fatalf("RenderAll: %v", err)
+	}
+	if n != 1 {
+		t.Errorf("expected 1 written, got %d", n)
+	}
+}
+
+func TestRenderAll_DryRun(t *testing.T) {
+	ir := shardIR(
+		[]api.Node{
+			{ID: "fa", Labels: []string{"File"}, Properties: map[string]any{"filePath": "src/a.go"}},
+			{ID: "fb", Labels: []string{"File"}, Properties: map[string]any{"filePath": "src/b.go"}},
+		},
+		[]api.Relationship{
+			{ID: "r1", Type: "imports", StartNode: "fa", EndNode: "fb"},
+		},
+	)
+	dir := t.TempDir()
+	c := makeRenderCache(ir)
+	n, err := RenderAll(dir, c, []string{"src/a.go"}, true)
+	if err != nil {
+		t.Fatalf("RenderAll dryRun: %v", err)
+	}
+	if n != 1 {
+		t.Errorf("dryRun: expected 1 counted, got %d", n)
+	}
+	// No actual files written.
+	entries, _ := os.ReadDir(dir)
+	if len(entries) != 0 {
+		t.Errorf("dry-run should not create files, found %d", len(entries))
+	}
+}
+
+func TestRenderAll_SkipsEmptyContent(t *testing.T) {
+	// A file not in the cache produces empty content → no shard written.
+	dir := t.TempDir()
+	c := makeRenderCache(shardIR(nil, nil))
+	n, err := RenderAll(dir, c, []string{"src/unknown.go"}, false)
+	if err != nil {
+		t.Fatalf("RenderAll: %v", err)
+	}
+	if n != 0 {
+		t.Errorf("unknown file should produce 0 written, got %d", n)
+	}
+}
+
 // ── Hook ─────────────────────────────────────────────────────────────────────
 
 func TestHook_InvalidJSONExitsCleanly(t *testing.T) {