chore: import upstream snapshot with attribution

internal/parser/opencode_storage_state.go

@@ -0,0 +1,98 @@
+// ABOUTME: Change-detection state for file-backed OpenCode storage sessions,
+// ABOUTME: built from the stat signature of every file the parser would read.
+package parser
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// StatOpenCodeStorageSessionState captures a change-detection state for a
+// file-backed OpenCode-format storage session: a digest over the name, size,
+// and nanosecond mtime of the session JSON and of every message and part
+// file its parse would read (the same .json filters as
+// loadOpenCodeStorageMessages and loadOpenCodeStorageParts). Two equal
+// states mean the parse inputs carry an identical stat signature, so a
+// session whose state matches a previously verified one can skip re-parsing.
+//
+// The signature is deliberately per-file rather than an aggregate max-mtime:
+// a composite max cannot see a child rewritten within one filesystem mtime
+// granule or with a restored timestamp, while a per-file (name, size,
+// mtimeNS) set narrows the blind spot to a same-size in-place rewrite that
+// also preserves the file's mtime. Callers that learn about a change out of
+// band (a watcher event naming a child file) must invalidate any trust in
+// the previous state rather than rely on the stat signature alone.
+//
+// ok is false when the session file is missing or a directory listing
+// fails, in which case the session must never be treated as unchanged.
+func StatOpenCodeStorageSessionState(sessionPath string) (string, bool) {
+	info, err := os.Stat(sessionPath)
+	if err != nil || !info.Mode().IsRegular() {
+		return "", false
+	}
+	h := sha256.New()
+	record := func(kind, name string, size, mtimeNS int64) {
+		fmt.Fprintf(h, "%s\x00%s\x00%d\x00%d\n", kind, name, size, mtimeNS)
+	}
+	record(
+		"session", filepath.Base(sessionPath),
+		info.Size(), info.ModTime().UnixNano(),
+	)
+
+	root := filepath.Dir(filepath.Dir(filepath.Dir(
+		filepath.Dir(sessionPath),
+	)))
+	sessionID := strings.TrimSuffix(
+		filepath.Base(sessionPath), filepath.Ext(sessionPath),
+	)
+	messageDir := filepath.Join(root, "storage", "message", sessionID)
+	msgEntries, err := os.ReadDir(messageDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Sprintf("%x", h.Sum(nil)), true
+		}
+		return "", false
+	}
+	for _, entry := range msgEntries {
+		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".json") {
+			continue
+		}
+		msgInfo, err := entry.Info()
+		if err != nil {
+			return "", false
+		}
+		record(
+			"message", entry.Name(),
+			msgInfo.Size(), msgInfo.ModTime().UnixNano(),
+		)
+		messageID := strings.TrimSuffix(
+			entry.Name(), filepath.Ext(entry.Name()),
+		)
+		partDir := filepath.Join(root, "storage", "part", messageID)
+		partEntries, err := os.ReadDir(partDir)
+		if err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return "", false
+		}
+		for _, partEntry := range partEntries {
+			if partEntry.IsDir() ||
+				!strings.HasSuffix(partEntry.Name(), ".json") {
+				continue
+			}
+			partInfo, err := partEntry.Info()
+			if err != nil {
+				return "", false
+			}
+			record(
+				"part", messageID+"/"+partEntry.Name(),
+				partInfo.Size(), partInfo.ModTime().UnixNano(),
+			)
+		}
+	}
+	return fmt.Sprintf("%x", h.Sum(nil)), true
+}