@m16khb/llm-wiki 0.1.0 → 0.1.2

package/internal/wiki/cleanup_plan.go

@@ -0,0 +1,569 @@
+package wiki
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+const cleanupPlanVersion = 1
+
+// CleanupAnalyzeOptions controls dry-run candidate generation for
+// LLM-reviewed cleanup planning. AnalyzeCleanup never writes to the vault.
+type CleanupAnalyzeOptions struct {
+	Scope       string `json:"scope"`
+	ArchiveRoot string `json:"archive_root,omitempty"`
+}
+
+// CleanupAnalysis is the review packet an agent can inspect before writing a
+// deterministic CleanupPlan.
+type CleanupAnalysis struct {
+	Date             string             `json:"date"`
+	Scope            string             `json:"scope"`
+	CandidateCount   int                `json:"candidate_count"`
+	Candidates       []CleanupCandidate `json:"candidates"`
+	AllowedActions   []string           `json:"allowed_actions"`
+	PlanSchema       CleanupPlan        `json:"plan_schema"`
+	LLMInstructions  []string           `json:"llm_instructions"`
+	Warnings         []string           `json:"warnings,omitempty"`
+	ProtectedRoots   []string           `json:"protected_roots"`
+	DestructiveGuard string             `json:"destructive_guard"`
+}
+
+// CleanupCandidate is one possible cleanup target surfaced for human/LLM
+// judgment.
+type CleanupCandidate struct {
+	ID                string                 `json:"id"`
+	Kind              string                 `json:"kind"`
+	Title             string                 `json:"title"`
+	Reason            string                 `json:"reason"`
+	Confidence        string                 `json:"confidence"`
+	Files             []CleanupCandidateFile `json:"files"`
+	RecommendedAction CleanupPlanAction      `json:"recommended_action"`
+	Warnings          []string               `json:"warnings,omitempty"`
+}
+
+// CleanupCandidateFile describes a vault file involved in a candidate.
+type CleanupCandidateFile struct {
+	Path       string `json:"path"`
+	Role       string `json:"role"`
+	TargetPath string `json:"target_path,omitempty"`
+}
+
+// CleanupPlan is the LLM-authored, deterministic cleanup plan schema accepted
+// by ApplyCleanupPlan. The executor validates every action before writing.
+type CleanupPlan struct {
+	Version int                 `json:"version"`
+	Scope   string              `json:"scope"`
+	Summary string              `json:"summary,omitempty"`
+	Actions []CleanupPlanAction `json:"actions"`
+}
+
+// CleanupPlanAction is one allowlisted action. Supported Type values:
+// "run_scope" and "rename_page".
+type CleanupPlanAction struct {
+	Type          string `json:"type"`
+	Scope         string `json:"scope,omitempty"`
+	ArchiveRoot   string `json:"archive_root,omitempty"`
+	FromPath      string `json:"from_path,omitempty"`
+	ToPath        string `json:"to_path,omitempty"`
+	CanonicalPath string `json:"canonical_path,omitempty"`
+	Slug          string `json:"slug,omitempty"`
+	Reason        string `json:"reason,omitempty"`
+}
+
+// CleanupPlanApplyOptions controls deterministic plan validation/application.
+// The default is dry-run; callers must set Apply to write.
+type CleanupPlanApplyOptions struct {
+	Apply bool        `json:"apply"`
+	Plan  CleanupPlan `json:"plan"`
+}
+
+// CleanupPlanApplyResult summarizes a plan validation or application.
+type CleanupPlanApplyResult struct {
+	Applied     bool                      `json:"applied"`
+	Date        string                    `json:"date"`
+	Scope       string                    `json:"scope"`
+	Summary     string                    `json:"summary,omitempty"`
+	Actions     []CleanupPlanActionResult `json:"actions"`
+	ReportPaths []string                  `json:"report_paths,omitempty"`
+	Warnings    []string                  `json:"warnings,omitempty"`
+}
+
+// CleanupPlanActionResult summarizes one action's validated/applied effects.
+type CleanupPlanActionResult struct {
+	Type           string   `json:"type"`
+	Scope          string   `json:"scope,omitempty"`
+	FromPath       string   `json:"from_path,omitempty"`
+	ToPath         string   `json:"to_path,omitempty"`
+	Applied        bool     `json:"applied"`
+	PlannedChanges int      `json:"planned_changes"`
+	Reason         string   `json:"reason,omitempty"`
+	ReportPaths    []string `json:"report_paths,omitempty"`
+	Warnings       []string `json:"warnings,omitempty"`
+}
+
+// AnalyzeCleanup returns an LLM-review packet for cleanup candidates without
+// modifying the vault.
+func (v *Vault) AnalyzeCleanup(opts CleanupAnalyzeOptions) (CleanupAnalysis, error) {
+	scope := cleanupScopeOrDefault(opts.Scope)
+	analysis := CleanupAnalysis{
+		Date:             v.nowDate(),
+		Scope:            scope,
+		AllowedActions:   []string{"run_scope", "rename_page"},
+		PlanSchema:       cleanupPlanSchema(scope, opts.ArchiveRoot),
+		LLMInstructions:  cleanupLLMInstructions(),
+		ProtectedRoots:   []string{".obsidian/", "10-sources/"},
+		DestructiveGuard: "analysis-only; no vault writes occur unless a validated plan is later run with --apply",
+	}
+	switch scope {
+	case "repository-references":
+		plan, err := v.planRepositoryReferenceCleanup(RepositoryReferenceCleanupOptions{ArchiveRoot: opts.ArchiveRoot})
+		if err != nil {
+			return CleanupAnalysis{}, err
+		}
+		analysis.Warnings = append(analysis.Warnings, plan.result.Warnings...)
+		analysis.Candidates = repositoryReferenceCleanupCandidates(plan)
+	case "duplicate-slugs":
+		plan, err := v.planDuplicateSlugCleanup(DuplicateSlugCleanupOptions{})
+		if err != nil {
+			return CleanupAnalysis{}, err
+		}
+		analysis.Warnings = append(analysis.Warnings, plan.result.Warnings...)
+		analysis.Candidates = duplicateSlugCleanupCandidates(plan)
+	default:
+		return CleanupAnalysis{}, fmt.Errorf("unsupported cleanup scope: %s", scope)
+	}
+	analysis.CandidateCount = len(analysis.Candidates)
+	return analysis, nil
+}
+
+// ApplyCleanupPlan validates every action, then optionally applies the plan.
+// Dry-run is the default and performs no writes.
+func (v *Vault) ApplyCleanupPlan(opts CleanupPlanApplyOptions) (CleanupPlanApplyResult, error) {
+	plan := normalizeCleanupPlan(opts.Plan)
+	if plan.Version != cleanupPlanVersion {
+		return CleanupPlanApplyResult{}, fmt.Errorf("unsupported cleanup plan version: %d", plan.Version)
+	}
+	if len(plan.Actions) == 0 {
+		return CleanupPlanApplyResult{}, errors.New("cleanup plan has no actions")
+	}
+	if err := validateCleanupPlanShape(plan); err != nil {
+		return CleanupPlanApplyResult{}, err
+	}
+	result := CleanupPlanApplyResult{
+		Applied: opts.Apply,
+		Date:    v.nowDate(),
+		Scope:   cleanupScopeOrDefault(plan.Scope),
+		Summary: plan.Summary,
+	}
+
+	validated := make([]cleanupPlanValidatedAction, 0, len(plan.Actions))
+	for _, action := range plan.Actions {
+		item, err := v.validateCleanupPlanAction(action)
+		if err != nil {
+			return result, err
+		}
+		validated = append(validated, item)
+	}
+	for _, item := range validated {
+		actionResult, err := v.applyCleanupPlanAction(item, opts.Apply)
+		if err != nil {
+			return result, err
+		}
+		result.Actions = append(result.Actions, actionResult)
+		result.Warnings = append(result.Warnings, actionResult.Warnings...)
+		result.ReportPaths = append(result.ReportPaths, actionResult.ReportPaths...)
+	}
+	sort.Strings(result.ReportPaths)
+	sort.Strings(result.Warnings)
+	if opts.Apply {
+		if err := v.writeCleanupPlanApplyReport(&result, plan); err != nil {
+			return result, err
+		}
+	}
+	return result, nil
+}
+
+func validateCleanupPlanShape(plan CleanupPlan) error {
+	hasRunScope := false
+	for _, action := range plan.Actions {
+		if action.Type == "run_scope" {
+			hasRunScope = true
+			break
+		}
+	}
+	if hasRunScope && len(plan.Actions) > 1 {
+		return errors.New("run_scope cleanup plan actions must be the only action in the plan")
+	}
+	return nil
+}
+
+type cleanupPlanValidatedAction struct {
+	action         CleanupPlanAction
+	fromAbs        string
+	toAbs          string
+	plannedChanges int
+	warnings       []string
+}
+
+func (v *Vault) validateCleanupPlanAction(action CleanupPlanAction) (cleanupPlanValidatedAction, error) {
+	action = normalizeCleanupPlanAction(action)
+	item := cleanupPlanValidatedAction{action: action}
+	switch action.Type {
+	case "run_scope":
+		switch action.Scope {
+		case "repository-references":
+			plan, err := v.planRepositoryReferenceCleanup(RepositoryReferenceCleanupOptions{ArchiveRoot: action.ArchiveRoot})
+			if err != nil {
+				return item, err
+			}
+			item.plannedChanges = len(plan.result.Bundles)
+			item.warnings = append(item.warnings, plan.result.Warnings...)
+		case "duplicate-slugs":
+			plan, err := v.planDuplicateSlugCleanup(DuplicateSlugCleanupOptions{})
+			if err != nil {
+				return item, err
+			}
+			item.plannedChanges = len(plan.result.Renames)
+			item.warnings = append(item.warnings, plan.result.Warnings...)
+		default:
+			return item, fmt.Errorf("unsupported cleanup run_scope scope: %s", action.Scope)
+		}
+	case "rename_page":
+		fromAbs, toAbs, err := v.validateCleanupPlanRename(action)
+		if err != nil {
+			return item, err
+		}
+		item.fromAbs = fromAbs
+		item.toAbs = toAbs
+		item.plannedChanges = 1
+	default:
+		return item, fmt.Errorf("unsupported cleanup plan action type: %s", action.Type)
+	}
+	return item, nil
+}
+
+func (v *Vault) applyCleanupPlanAction(item cleanupPlanValidatedAction, apply bool) (CleanupPlanActionResult, error) {
+	action := item.action
+	result := CleanupPlanActionResult{
+		Type:           action.Type,
+		Scope:          action.Scope,
+		FromPath:       action.FromPath,
+		ToPath:         action.ToPath,
+		Applied:        apply,
+		PlannedChanges: item.plannedChanges,
+		Reason:         action.Reason,
+		Warnings:       append([]string(nil), item.warnings...),
+	}
+	switch action.Type {
+	case "run_scope":
+		switch action.Scope {
+		case "repository-references":
+			scopeResult, err := v.CleanupRepositoryReferences(RepositoryReferenceCleanupOptions{Apply: apply, ArchiveRoot: action.ArchiveRoot})
+			if err != nil {
+				return result, err
+			}
+			result.PlannedChanges = len(scopeResult.Bundles)
+			result.ReportPaths = append(result.ReportPaths, scopeResult.ReportPaths...)
+			result.Warnings = append(result.Warnings, scopeResult.Warnings...)
+		case "duplicate-slugs":
+			scopeResult, err := v.CleanupDuplicateSlugs(DuplicateSlugCleanupOptions{Apply: apply})
+			if err != nil {
+				return result, err
+			}
+			result.PlannedChanges = len(scopeResult.Renames)
+			result.ReportPaths = append(result.ReportPaths, scopeResult.ReportPaths...)
+			result.Warnings = append(result.Warnings, scopeResult.Warnings...)
+		}
+	case "rename_page":
+		if apply {
+			if err := v.applyCleanupPlanRename(action, item.fromAbs, item.toAbs); err != nil {
+				return result, err
+			}
+		}
+	}
+	sort.Strings(result.ReportPaths)
+	sort.Strings(result.Warnings)
+	return result, nil
+}
+
+func (v *Vault) validateCleanupPlanRename(action CleanupPlanAction) (string, string, error) {
+	fromPath := action.FromPath
+	toPath := action.ToPath
+	if fromPath == "" || toPath == "" {
+		return "", "", errors.New("rename_page requires from_path and to_path")
+	}
+	if !strings.EqualFold(filepath.Ext(fromPath), ".md") || !strings.EqualFold(filepath.Ext(toPath), ".md") {
+		return "", "", errors.New("rename_page paths must be markdown files")
+	}
+	if isCleanupPlanProtectedPath(fromPath) {
+		return "", "", fmt.Errorf("rename_page source is protected: %s", fromPath)
+	}
+	if isCleanupPlanProtectedPath(toPath) {
+		return "", "", fmt.Errorf("rename_page target is protected: %s", toPath)
+	}
+	if fromPath == toPath {
+		return "", "", fmt.Errorf("rename_page source and target are identical: %s", fromPath)
+	}
+	fromAbs, err := v.SafeJoin(fromPath)
+	if err != nil {
+		return "", "", err
+	}
+	toAbs, err := v.SafeJoin(toPath)
+	if err != nil {
+		return "", "", err
+	}
+	if _, err := os.Stat(fromAbs); err != nil {
+		return "", "", err
+	}
+	if _, err := os.Stat(toAbs); err == nil {
+		return "", "", fmt.Errorf("rename_page target already exists: %s", toPath)
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return "", "", err
+	}
+	return fromAbs, toAbs, nil
+}
+
+func (v *Vault) applyCleanupPlanRename(action CleanupPlanAction, fromAbs, toAbs string) error {
+	data, err := os.ReadFile(fromAbs)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(toAbs), 0o755); err != nil {
+		return err
+	}
+	updated := markCleanupPlanRenamed(v.nowDate(), action, string(data))
+	if err := os.WriteFile(toAbs, []byte(updated), 0o644); err != nil {
+		return err
+	}
+	return os.Remove(fromAbs)
+}
+
+func markCleanupPlanRenamed(date string, action CleanupPlanAction, content string) string {
+	canonical := strings.TrimSpace(action.CanonicalPath)
+	if canonical == "" {
+		canonical = "not specified"
+	}
+	notice := fmt.Sprintf("> Renamed by LLM-reviewed cleanup plan on %s. Reason: %s. Previous path: `%s`. Canonical/reference path: `%s`.\n\n", date, strings.TrimSpace(action.Reason), action.FromPath, canonical)
+	lines := strings.Split(content, "\n")
+	if len(lines) > 0 && strings.TrimSpace(lines[0]) == "---" {
+		end := -1
+		for i := 1; i < len(lines); i++ {
+			if strings.TrimSpace(lines[i]) == "---" {
+				end = i
+				break
+			}
+		}
+		if end > 0 {
+			header := upsertFrontmatterField(lines[1:end], "updated", date)
+			var b strings.Builder
+			b.WriteString("---\n")
+			b.WriteString(strings.Join(header, "\n"))
+			b.WriteString("\n---\n\n")
+			b.WriteString(notice)
+			b.WriteString(strings.TrimLeft(strings.Join(lines[end+1:], "\n"), "\n"))
+			if !strings.HasSuffix(b.String(), "\n") {
+				b.WriteString("\n")
+			}
+			return b.String()
+		}
+	}
+	return fmt.Sprintf("---\ntitle: %s\ntype: reference\nstatus: active\ncreated: %s\nupdated: %s\ntags: [cleanup, llm-reviewed]\ndomain: meta\n---\n\n%s%s\n", yamlQuote(titleizeSlug(strings.TrimSuffix(filepath.Base(action.ToPath), ".md"))), date, date, notice, strings.TrimSpace(content))
+}
+
+func (v *Vault) writeCleanupPlanApplyReport(result *CleanupPlanApplyResult, plan CleanupPlan) error {
+	reportRel, err := v.uniqueVaultRel(fmt.Sprintf("00-meta/reports/cleanup-plan-apply-%s.md", result.Date))
+	if err != nil {
+		return err
+	}
+	abs, err := v.SafeJoin(reportRel)
+	if err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+		return err
+	}
+	var b strings.Builder
+	b.WriteString("---\n")
+	fmt.Fprintf(&b, "title: %s\n", yamlQuote("LLM Cleanup Plan Apply "+result.Date))
+	b.WriteString("type: lint-report\n")
+	b.WriteString("status: active\n")
+	fmt.Fprintf(&b, "created: %s\n", result.Date)
+	fmt.Fprintf(&b, "updated: %s\n", result.Date)
+	b.WriteString("tags: [cleanup, llm-reviewed, ai-slop-cleaner]\n")
+	b.WriteString("domain: meta\n")
+	b.WriteString("---\n\n")
+	fmt.Fprintf(&b, "# LLM Cleanup Plan Apply %s\n\n", result.Date)
+	fmt.Fprintf(&b, "- Applied: `%t`\n", result.Applied)
+	if strings.TrimSpace(plan.Summary) != "" {
+		fmt.Fprintf(&b, "- Summary: %s\n", strings.TrimSpace(plan.Summary))
+	}
+	b.WriteString("\n## Actions\n\n")
+	for i, action := range result.Actions {
+		fmt.Fprintf(&b, "### %d. `%s`\n\n", i+1, action.Type)
+		if action.Scope != "" {
+			fmt.Fprintf(&b, "- Scope: `%s`\n", action.Scope)
+		}
+		if action.FromPath != "" || action.ToPath != "" {
+			fmt.Fprintf(&b, "- Rename: `%s` → `%s`\n", action.FromPath, action.ToPath)
+		}
+		fmt.Fprintf(&b, "- Planned changes: `%d`\n", action.PlannedChanges)
+		if strings.TrimSpace(action.Reason) != "" {
+			fmt.Fprintf(&b, "- Reason: %s\n", strings.TrimSpace(action.Reason))
+		}
+		if len(action.ReportPaths) > 0 {
+			fmt.Fprintf(&b, "- Reports: `%s`\n", strings.Join(action.ReportPaths, "`, `"))
+		}
+		b.WriteString("\n")
+	}
+	if len(result.Warnings) > 0 {
+		b.WriteString("## Warnings\n\n")
+		for _, warning := range result.Warnings {
+			fmt.Fprintf(&b, "- %s\n", warning)
+		}
+		b.WriteString("\n")
+	}
+	b.WriteString("## Changelog\n\n")
+	fmt.Fprintf(&b, "- %s: Generated by `llm-wiki cleanup apply-plan --apply`.\n", result.Date)
+	if err := os.WriteFile(abs, []byte(b.String()), 0o644); err != nil {
+		return err
+	}
+	result.ReportPaths = append(result.ReportPaths, reportRel)
+	sort.Strings(result.ReportPaths)
+	return nil
+}
+
+func repositoryReferenceCleanupCandidates(plan repositoryReferenceCleanupPlan) []CleanupCandidate {
+	candidates := make([]CleanupCandidate, 0, len(plan.result.Bundles))
+	for _, bundle := range plan.result.Bundles {
+		files := []CleanupCandidateFile{{
+			Path: bundle.BundlePath,
+			Role: "would_create_bundle",
+		}}
+		for i, fragmentPath := range bundle.FragmentPaths {
+			file := CleanupCandidateFile{Path: fragmentPath, Role: "fragment"}
+			if i < len(bundle.ArchivedPaths) {
+				file.TargetPath = bundle.ArchivedPaths[i]
+			}
+			files = append(files, file)
+		}
+		candidates = append(candidates, CleanupCandidate{
+			ID:         "repository-references:" + bundle.Repository,
+			Kind:       "repository-reference-bundle",
+			Title:      titleizeSlug(bundle.Repository) + " repository reference fragments",
+			Reason:     fmt.Sprintf("%d dated repository-reference fragments can be consolidated into one canonical bundle.", len(bundle.FragmentPaths)),
+			Confidence: "high",
+			Files:      files,
+			RecommendedAction: CleanupPlanAction{
+				Type:        "run_scope",
+				Scope:       "repository-references",
+				ArchiveRoot: plan.result.ArchiveRoot,
+				Reason:      "Consolidate dated repository-reference fragments through the guarded deterministic cleanup scope.",
+			},
+		})
+	}
+	return candidates
+}
+
+func duplicateSlugCleanupCandidates(plan duplicateSlugCleanupPlan) []CleanupCandidate {
+	bySlug := map[string][]DuplicateSlugRename{}
+	for _, rename := range plan.result.Renames {
+		bySlug[rename.Slug] = append(bySlug[rename.Slug], rename)
+	}
+	slugs := make([]string, 0, len(bySlug))
+	for slug := range bySlug {
+		slugs = append(slugs, slug)
+	}
+	sort.Strings(slugs)
+	candidates := make([]CleanupCandidate, 0, len(slugs))
+	for _, slug := range slugs {
+		renames := bySlug[slug]
+		sort.Slice(renames, func(i, j int) bool { return renames[i].FromPath < renames[j].FromPath })
+		files := []CleanupCandidateFile{{Path: renames[0].CanonicalPath, Role: "canonical"}}
+		for _, rename := range renames {
+			files = append(files, CleanupCandidateFile{Path: rename.FromPath, Role: "duplicate", TargetPath: rename.ToPath})
+		}
+		candidates = append(candidates, CleanupCandidate{
+			ID:         "duplicate-slugs:" + slug,
+			Kind:       "duplicate-slug",
+			Title:      "Duplicate slug: " + slug,
+			Reason:     fmt.Sprintf("%d non-canonical pages share slug %q and can be renamed to remove Obsidian ambiguity warnings.", len(renames), slug),
+			Confidence: "high",
+			Files:      files,
+			RecommendedAction: CleanupPlanAction{
+				Type:   "run_scope",
+				Scope:  "duplicate-slugs",
+				Reason: "Resolve duplicate slug warnings through the guarded deterministic cleanup scope.",
+			},
+		})
+	}
+	return candidates
+}
+
+func cleanupPlanSchema(scope, archiveRoot string) CleanupPlan {
+	action := CleanupPlanAction{Type: "run_scope", Scope: cleanupScopeOrDefault(scope), Reason: "LLM-reviewed reason for applying this guarded cleanup action."}
+	if strings.TrimSpace(archiveRoot) != "" {
+		action.ArchiveRoot = strings.Trim(strings.TrimSpace(filepath.ToSlash(archiveRoot)), "/")
+	}
+	return CleanupPlan{
+		Version: cleanupPlanVersion,
+		Scope:   cleanupScopeOrDefault(scope),
+		Summary: "Explain why these candidates are true cleanup targets and why this strategy is safest.",
+		Actions: []CleanupPlanAction{action},
+	}
+}
+
+func cleanupLLMInstructions() []string {
+	return []string{
+		"Review candidates as suggestions, not commands; include only true cleanup targets in the plan.",
+		"Prefer run_scope for existing guarded cleanup behavior; use rename_page only for a narrowly justified targeted rename.",
+		"Do not edit 10-sources bodies, .obsidian, absolute paths, or paths containing traversal.",
+		"Do not invent files; every rename_page from_path must exist and every to_path must be a new vault-relative Markdown path.",
+		"Keep destructive execution separate: first validate without --apply, then apply only after the dry-run output matches the intended strategy.",
+	}
+}
+
+func normalizeCleanupPlan(plan CleanupPlan) CleanupPlan {
+	plan.Scope = cleanupScopeOrDefault(plan.Scope)
+	for i, action := range plan.Actions {
+		plan.Actions[i] = normalizeCleanupPlanAction(action)
+	}
+	return plan
+}
+
+func normalizeCleanupPlanAction(action CleanupPlanAction) CleanupPlanAction {
+	action.Type = strings.TrimSpace(action.Type)
+	action.Scope = cleanupScopeOrDefault(action.Scope)
+	action.ArchiveRoot = strings.Trim(strings.TrimSpace(filepath.ToSlash(action.ArchiveRoot)), "/")
+	action.FromPath = cleanCleanupPlanPath(action.FromPath)
+	action.ToPath = cleanCleanupPlanPath(action.ToPath)
+	action.CanonicalPath = cleanCleanupPlanPath(action.CanonicalPath)
+	action.Slug = strings.TrimSpace(action.Slug)
+	action.Reason = strings.TrimSpace(action.Reason)
+	return action
+}
+
+func cleanupScopeOrDefault(scope string) string {
+	scope = strings.TrimSpace(scope)
+	if scope == "" {
+		return "repository-references"
+	}
+	return scope
+}
+
+func cleanCleanupPlanPath(path string) string {
+	path = strings.TrimSpace(filepath.ToSlash(path))
+	if path == "" {
+		return ""
+	}
+	return path
+}
+
+func isCleanupPlanProtectedPath(path string) bool {
+	path = cleanCleanupPlanPath(path)
+	return path == ".obsidian" || strings.HasPrefix(path, ".obsidian/") || path == "10-sources" || strings.HasPrefix(path, "10-sources/")
+}