refactor: apply functional options to long param functions (#153)

## Summary

Closes #145
Closes #146
Closes #147

## Self-review

### Touched

**Pipeline**

- [ ] `pkg/parser/` — fuzz target covers any new shape
- [ ] `pkg/transformer/` or `pkg/diff/` — ID stability / hash inputs
unchanged
- [ ] `pkg/emitter/` — exactly one snapshot per write
- [x] `pkg/store/` + `migrations/` — FTS5 triggers in sync;
`add-store-query` followed
- [ ] `pkg/query/` or `pkg/compiler/` — token budget honored

**MCP surface**

- [x] `pkg/mcp/` — `skills/remind` (read) or `skills/memoize` (write)
updated
- [ ] `pkg/temperature/` — both public skills reflect new values

**Edges**

- [ ] `cmd/remindb/` — README CLI section updated
- [ ] `internal/ignore/`, `internal/tempfile/`, `internal/bench/` —
relevant fuzz / fixture / scenario added
- [ ] `plugins/<agent>/` — manifest version bumped if shipping

### Process

- [ ] Tested manually via CLI or local MCP plugin install
- [x] `make test-all` + `make fuzz` green

---------

Signed-off-by: radimsem <me@radimsemerak.cz>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: radimsem

cmd/remindb/serve.go

@@ -13,6 +13,7 @@ import (
 	"github.com/radimsem/remindb/pkg/config"
 	"github.com/radimsem/remindb/pkg/logbuf"
 	remindb "github.com/radimsem/remindb/pkg/mcp"
+	"github.com/radimsem/remindb/pkg/mcp/rescan"
 	"github.com/radimsem/remindb/pkg/mcp/rescanlog"
 	"github.com/radimsem/remindb/pkg/mcp/rescanstat"
 	"github.com/radimsem/remindb/pkg/mcp/sessionlog"
@@ -174,14 +175,19 @@ func runServe(cmd *cobra.Command, _ []string) error {
 			return err
 		}
 
-		rescan, err := remindb.NewRescanLoop(st, sourceDir, rescanInterval, workspaceCfg.Compile, logger, rescanStatus, rescanLog)
+		rescanLoop, err := rescan.New(st, sourceDir, rescanInterval,
+			rescan.WithCompileConfig(workspaceCfg.Compile),
+			rescan.WithLogger(logger),
+			rescan.WithStatus(rescanStatus),
+			rescan.WithRescanLog(rescanLog),
+		)
 		if err != nil {
 			return err
 		}
-		rescan.SetChangeObserver(srv.NotifyRescan)
+		rescanLoop.SetChangeObserver(srv.NotifyRescan)
 
 		g.Go(func() error {
-			rescan.Run(ctx)
+			rescanLoop.Run(ctx)
 			return nil
 		})
 	}

internal/mcptest/mcptest.go

@@ -15,6 +15,7 @@ import (
 	"github.com/radimsem/remindb/pkg/config"
 	"github.com/radimsem/remindb/pkg/logbuf"
 	remindb "github.com/radimsem/remindb/pkg/mcp"
+	"github.com/radimsem/remindb/pkg/mcp/rescan"
 	"github.com/radimsem/remindb/pkg/mcp/rescanstat"
 	"github.com/radimsem/remindb/pkg/mcp/sessionlog"
 	"github.com/radimsem/remindb/pkg/store"
@@ -188,9 +189,9 @@ func NewEnvWithRescan(t *testing.T) *Env {
 		t.Fatalf("NewServer: %v", err)
 	}
 
-	loop, err := remindb.NewRescanLoop(st, dir, time.Second, config.CompileConfig{}, nil, status, nil)
+	loop, err := rescan.New(st, dir, time.Second, rescan.WithStatus(status))
 	if err != nil {
-		t.Fatalf("NewRescanLoop: %v", err)
+		t.Fatalf("rescan.New: %v", err)
 	}
 
 	loopCtx, cancelLoop := context.WithCancel(context.Background())

pkg/compiler/compiler_test.go

@@ -831,7 +831,7 @@ func TestCompile_WikilinkResolvesCrossFile(t *testing.T) {
 		t.Fatalf("no source paragraph found in a.md: %+v", aNodes)
 	}
 
-	related, err := st.GetRelatedNodes(ctx, sourceID, store.DirectionOut, 1, 0, 10)
+	related, err := st.GetRelatedNodes(ctx, sourceID, store.WithDirection(store.DirectionOut), store.WithMaxDepth(1), store.WithLimit(10))
 	if err != nil {
 		t.Fatalf("GetRelatedNodes: %v", err)
 	}
@@ -910,7 +910,7 @@ func TestCompile_WikilinkPendingResolvesOnLaterCompile(t *testing.T) {
 		t.Fatalf("no source paragraph found in a.md after second compile: %+v", aNodes)
 	}
 
-	related, err := st.GetRelatedNodes(ctx, sourceID, store.DirectionOut, 1, 0, 10)
+	related, err := st.GetRelatedNodes(ctx, sourceID, store.WithDirection(store.DirectionOut), store.WithMaxDepth(1), store.WithLimit(10))
 	if err != nil {
 		t.Fatalf("GetRelatedNodes: %v", err)
 	}

pkg/emitter/emitter.go

@@ -81,7 +81,11 @@ func Emit(ctx context.Context, st *store.Store, opts ...Option) error {
 			}
 		}
 
-		snapID, err := st.CreateSnapshotTx(ctx, tx, o.cursorHash, o.message, o.compileRoot)
+		snapID, err := st.CreateSnapshotTx(ctx, tx,
+			store.WithCursorHash(o.cursorHash),
+			store.WithMessage(o.message),
+			store.WithCompileRoot(o.compileRoot),
+		)
 		if err != nil {
 			return fmt.Errorf("failed to create: snapshot: %w", err)
 		}

pkg/mcp/initial_test.go

@@ -0,0 +1,74 @@
+package mcp
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/radimsem/remindb/internal/testutil"
+)
+
+func TestMaybeInitialCompile_EmptyDB(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, dir, "a.md", "# A\n\nBody.\n")
+	writeFile(t, dir, "b.md", "# B\n\nBody.\n")
+
+	st := testutil.OpenTestDB(t)
+	ctx := context.Background()
+
+	if err := MaybeInitialCompile(ctx, st, dir, nil); err != nil {
+		t.Fatalf("MaybeInitialCompile: %v", err)
+	}
+
+	roots, err := st.GetRootNodes(ctx)
+	if err != nil {
+		t.Fatalf("GetRootNodes: %v", err)
+	}
+	if len(roots) == 0 {
+		t.Error("expected nodes to be compiled on empty DB")
+	}
+}
+
+func TestMaybeInitialCompile_NonEmptyDB(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, dir, "a.md", "# A\n\nBody.\n")
+
+	st := testutil.OpenTestDB(t)
+	ctx := context.Background()
+
+	if err := MaybeInitialCompile(ctx, st, dir, nil); err != nil {
+		t.Fatalf("seed compile: %v", err)
+	}
+
+	before, err := st.GetRootNodes(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	writeFile(t, dir, "new.md", "# New\n")
+
+	if err := MaybeInitialCompile(ctx, st, dir, nil); err != nil {
+		t.Fatalf("MaybeInitialCompile: %v", err)
+	}
+
+	after, err := st.GetRootNodes(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(after) != len(before) {
+		t.Errorf("root count changed: before=%d after=%d (MaybeInitialCompile ran on non-empty DB)", len(before), len(after))
+	}
+}
+
+func writeFile(t *testing.T, dir, name, content string) {
+	t.Helper()
+	p := filepath.Join(dir, name)
+
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}

pkg/mcp/rescan.go pkg/mcp/rescan/rescan.gopkg/mcp/rescan.go renamed to pkg/mcp/rescan/rescan.go

@@ -1,4 +1,5 @@
-package mcp
+// Package rescan periodically recompiles a source tree into the store.
+package rescan
 
 import (
 	"context"
@@ -31,7 +32,32 @@ const (
 	defaultSettleTime     = 500 * time.Millisecond
 )
 
-type RescanLoop struct {
+type Option func(*options)
+
+type options struct {
+	compileConfig config.CompileConfig
+	logger        *slog.Logger
+	status        *rescanstat.Status
+	rescanLog     *rescanlog.Sink
+}
+
+func WithCompileConfig(cc config.CompileConfig) Option {
+	return func(o *options) { o.compileConfig = cc }
+}
+
+func WithLogger(l *slog.Logger) Option {
+	return func(o *options) { o.logger = l }
+}
+
+func WithStatus(s *rescanstat.Status) Option {
+	return func(o *options) { o.status = s }
+}
+
+func WithRescanLog(s *rescanlog.Sink) Option {
+	return func(o *options) { o.rescanLog = s }
+}
+
+type Loop struct {
 	store             *store.Store
 	dir               string
 	bootstrapInterval time.Duration
@@ -50,22 +76,27 @@ type RescanLoop struct {
 	onChange          func()
 }
 
-// SetChangeObserver sets a callback fired after a scan that mutated the store, set before Run (nil disables).
-func (r *RescanLoop) SetChangeObserver(fn func()) {
+func (r *Loop) SetChangeObserver(fn func()) {
 	r.onChange = fn
 }
 
-func (r *RescanLoop) notifyChange() {
+func (r *Loop) notifyChange() {
 	if r.onChange != nil {
 		r.onChange()
 	}
 }
 
-func NewRescanLoop(st *store.Store, dir string, interval time.Duration, cc config.CompileConfig, logger *slog.Logger, status *rescanstat.Status, rescanLog *rescanlog.Sink) (*RescanLoop, error) {
+func New(st *store.Store, dir string, interval time.Duration, opts ...Option) (*Loop, error) {
+	var o options
+	for _, opt := range opts {
+		opt(&o)
+	}
+
 	if interval <= 0 {
 		interval = defaultRescanInterval
 	}
-	logger = loghelper.OrDiscard(logger)
+	logger := loghelper.OrDiscard(o.logger)
+	status := o.status
 	if status == nil {
 		status = rescanstat.New()
 	}
@@ -75,7 +106,7 @@ func NewRescanLoop(st *store.Store, dir string, interval time.Duration, cc confi
 		return nil, fmt.Errorf("failed to load: %s: %w", ignore.Path, err)
 	}
 
-	return &RescanLoop{
+	return &Loop{
 		store:             st,
 		dir:               dir,
 		bootstrapInterval: interval,
@@ -87,16 +118,15 @@ func NewRescanLoop(st *store.Store, dir string, interval time.Duration, cc confi
 		modTimes:          make(map[string]time.Time),
 		logger:            logger,
 		ignore:            matcher,
-		compileOpts:       compiler.ConfigOptions(cc),
+		compileOpts:       compiler.ConfigOptions(o.compileConfig),
 		status:            status,
-		rescanLog:         rescanLog,
+		rescanLog:         o.rescanLog,
 	}, nil
 }
 
-func (r *RescanLoop) Run(ctx context.Context) {
+func (r *Loop) Run(ctx context.Context) {
 	r.reloadConfig()
 
-	// Startup reconcile catches edits made between the last compile and now.
 	if r.enabled {
 		r.scan(ctx)
 	}
@@ -122,8 +152,7 @@ func (r *RescanLoop) Run(ctx context.Context) {
 	}
 }
 
-// Re-source the rescan block from config.json.
-func (r *RescanLoop) reloadConfig() (intervalChanged bool) {
+func (r *Loop) reloadConfig() (intervalChanged bool) {
 	path := filepath.Join(r.dir, config.DirName, config.FileName)
 
 	data, err := os.ReadFile(path)
@@ -167,7 +196,7 @@ func (r *RescanLoop) reloadConfig() (intervalChanged bool) {
 	return intervalChanged
 }
 
-func (r *RescanLoop) scan(ctx context.Context) {
+func (r *Loop) scan(ctx context.Context) {
 	var changed []string
 	seen := make(map[string]bool, len(r.modTimes))
 	pending := make(map[string]time.Time)
@@ -221,7 +250,6 @@ func (r *RescanLoop) scan(ctx context.Context) {
 
 		mtime := info.ModTime()
 
-		// Skip files still settling.
 		if now.Sub(mtime) < r.settle {
 			return nil
 		}
@@ -234,7 +262,6 @@ func (r *RescanLoop) scan(ctx context.Context) {
 		return nil
 	})
 
-	// Purge entries for deleted files only when the walk was complete.
 	if walkErr != nil {
 		r.logger.Error("rescan: walk aborted", "dir", r.dir, "err", walkErr)
 		snap.Error = walkErr.Error()
@@ -255,7 +282,6 @@ func (r *RescanLoop) scan(ctx context.Context) {
 		deleted = append(deleted, rel)
 	}
 
-	// Lock only around store mutations.
 	r.store.OpMu.Lock()
 	defer r.store.OpMu.Unlock()
 
@@ -297,8 +323,7 @@ func (r *RescanLoop) scan(ctx context.Context) {
 	r.notifyChange()
 }
 
-// Returns one PurgedFile per source file that lost nodes.
-func (r *RescanLoop) reconcileDeleted(ctx context.Context, deleted []string) []rescanstat.PurgedFile {
+func (r *Loop) reconcileDeleted(ctx context.Context, deleted []string) []rescanstat.PurgedFile {
 	if len(deleted) == 0 {
 		return nil
 	}
@@ -323,7 +348,6 @@ func (r *RescanLoop) reconcileDeleted(ctx context.Context, deleted []string) []r
 			OldContent: n.Content,
 		})
 
-		// "rem:" prefix keeps the delete cursor-hash domain disjoint from compile's.
 		synthetic = append(synthetic, &parser.ContextNode{ContentHash: "rem:" + n.ID + ":" + n.ContentHash})
 		counts[n.SourceFile]++
 	}