@peaske7/readit 0.2.0 → 0.3.0-rc.0

package/go/internal/server/sse.go

@@ -0,0 +1,140 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"sync"
+	"time"
+)
+
+// SSEBroker manages Server-Sent Event connections for document updates and heartbeat.
+type SSEBroker struct {
+	docClients       map[chan string]struct{}
+	heartbeatClients map[chan string]struct{}
+	mu               sync.Mutex
+	shutdownTimer    *time.Timer
+	shutdownEpoch    int
+	isDev            bool
+	onShutdown       func()
+}
+
+func NewSSEBroker(isDev bool, onShutdown func()) *SSEBroker {
+	return &SSEBroker{
+		docClients:       make(map[chan string]struct{}),
+		heartbeatClients: make(map[chan string]struct{}),
+		isDev:            isDev,
+		onShutdown:       onShutdown,
+	}
+}
+
+func (b *SSEBroker) Broadcast(event string) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	for ch := range b.docClients {
+		select {
+		case ch <- event:
+		default:
+		}
+	}
+}
+
+func (b *SSEBroker) DocumentStream(w http.ResponseWriter, r *http.Request) {
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "streaming not supported", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+
+	ch := make(chan string, 16)
+	b.mu.Lock()
+	b.docClients[ch] = struct{}{}
+	b.mu.Unlock()
+
+	defer func() {
+		b.mu.Lock()
+		delete(b.docClients, ch)
+		b.mu.Unlock()
+	}()
+
+	_, _ = fmt.Fprint(w, ": connected\n\n")
+	flusher.Flush()
+
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-r.Context().Done():
+			return
+		case msg := <-ch:
+			_, _ = fmt.Fprintf(w, "data: %s\n\n", msg)
+			flusher.Flush()
+		case <-ticker.C:
+			_, _ = fmt.Fprint(w, ": ping\n\n")
+			flusher.Flush()
+		}
+	}
+}
+
+func (b *SSEBroker) Heartbeat(w http.ResponseWriter, r *http.Request) {
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "streaming not supported", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+
+	ch := make(chan string, 16)
+	b.mu.Lock()
+	b.heartbeatClients[ch] = struct{}{}
+	if b.shutdownTimer != nil {
+		b.shutdownTimer.Stop()
+		b.shutdownTimer = nil
+	}
+	b.shutdownEpoch++
+	b.mu.Unlock()
+
+	defer func() {
+		b.mu.Lock()
+		delete(b.heartbeatClients, ch)
+		if len(b.heartbeatClients) == 0 && !b.isDev && b.onShutdown != nil {
+			if b.shutdownTimer != nil {
+				b.shutdownTimer.Stop()
+			}
+			b.shutdownEpoch++
+			epoch := b.shutdownEpoch
+			b.shutdownTimer = time.AfterFunc(1500*time.Millisecond, func() {
+				b.mu.Lock()
+				shouldShutdown := b.shutdownEpoch == epoch
+				b.mu.Unlock()
+				if shouldShutdown {
+					b.onShutdown()
+				}
+			})
+		}
+		b.mu.Unlock()
+	}()
+
+	_, _ = fmt.Fprint(w, ": connected\n\n")
+	flusher.Flush()
+
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-r.Context().Done():
+			return
+		case <-ticker.C:
+			_, _ = fmt.Fprint(w, ": ping\n\n")
+			flusher.Flush()
+		}
+	}
+}

package/go/internal/server/storage.go

@@ -0,0 +1,275 @@
+package server
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	mrand "math/rand"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+var (
+	frontMatterRe      = regexp.MustCompile(`(?s)^---\n(.*?)\n---`)
+	frontMatterStripRe = regexp.MustCompile(`(?s)^---\n.*?\n---\n*`)
+	commentMetaRe      = regexp.MustCompile(`<!--\s*c:([^|]+)\|([^|>]+?)(?:\|([^>]*?))?\s*-->`)
+	anchorPrefixRe     = regexp.MustCompile(`<!--\s*anchor:([A-Za-z0-9+/=]+)\s*-->`)
+)
+
+func CommentPath(filePath string) (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("cannot determine home directory: %w", err)
+	}
+	abs, err := filepath.Abs(filePath)
+	if err != nil {
+		return "", fmt.Errorf("cannot resolve absolute path for %s: %w", filePath, err)
+	}
+
+	stripped := abs
+	if runtime.GOOS == "windows" {
+		if len(stripped) >= 2 && stripped[1] == ':' {
+			stripped = stripped[2:]
+		}
+	}
+	stripped = strings.TrimPrefix(stripped, "/")
+
+	ext := filepath.Ext(stripped)
+	if ext != "" {
+		stripped = stripped[:len(stripped)-len(ext)]
+	}
+
+	return filepath.Join(home, ".readit", "comments", stripped+".comments.md"), nil
+}
+
+func ComputeHash(content []byte) string {
+	h := sha256.Sum256(content)
+	return fmt.Sprintf("%x", h[:])[:HashLength]
+}
+
+func ParseCommentFile(data []byte) (CommentFile, error) {
+	content := string(data)
+	cf := CommentFile{Version: FormatVersion}
+
+	if fm := frontMatterRe.FindStringSubmatch(content); len(fm) > 1 {
+		for line := range strings.SplitSeq(fm[1], "\n") {
+			line = strings.TrimSpace(line)
+			if k, v, ok := strings.Cut(line, ":"); ok {
+				v = strings.TrimSpace(v)
+				switch strings.TrimSpace(k) {
+				case "source":
+					cf.Source = v
+				case "hash":
+					cf.Hash = v
+				case "version":
+					_, _ = fmt.Sscanf(v, "%d", &cf.Version)
+				}
+			}
+		}
+	}
+
+	body := frontMatterStripRe.ReplaceAllString(content, "")
+	body = strings.TrimSpace(body)
+	if body == "" {
+		return cf, nil
+	}
+
+	markers := commentMetaRe.FindAllStringIndex(body, -1)
+	for i, loc := range markers {
+		var block string
+		if i+1 < len(markers) {
+			block = body[loc[0]:markers[i+1][0]]
+		} else {
+			block = body[loc[0]:]
+		}
+		block = strings.TrimSpace(block)
+		if block == "" {
+			continue
+		}
+		if c, ok := parseCommentBlock(block); ok {
+			cf.Comments = append(cf.Comments, c)
+		}
+	}
+
+	return cf, nil
+}
+
+func parseCommentBlock(block string) (Comment, bool) {
+	meta := commentMetaRe.FindStringSubmatch(block)
+	if meta == nil {
+		return Comment{}, false
+	}
+
+	c := Comment{
+		ID:        strings.TrimSpace(meta[1]),
+		LineHint:  strings.TrimSpace(meta[2]),
+		CreatedAt: strings.TrimSpace(meta[3]),
+	}
+
+	// Optional anchor prefix (base64-encoded)
+	if ap := anchorPrefixRe.FindStringSubmatch(block); len(ap) > 1 {
+		if decoded, err := base64.StdEncoding.DecodeString(strings.TrimSpace(ap[1])); err == nil {
+			c.AnchorPrefix = string(decoded)
+		} else {
+			// Fallback: treat as raw text for backward compatibility
+			c.AnchorPrefix = strings.TrimSpace(ap[1])
+		}
+	}
+
+	bodyLines := strings.Split(block, "\n")
+	pastMeta := false
+	inLeadingBlockquote := false
+	pastBlockquote := false
+	var selectedLines []string
+	var commentLines []string
+
+	for _, line := range bodyLines {
+		if commentMetaRe.MatchString(line) || anchorPrefixRe.MatchString(line) {
+			pastMeta = true
+			continue
+		}
+		if !pastBlockquote && pastMeta && (strings.HasPrefix(line, "> ") || line == ">") {
+			inLeadingBlockquote = true
+			// Extract the text after "> "
+			if strings.HasPrefix(line, "> ") {
+				selectedLines = append(selectedLines, line[2:])
+			} else {
+				selectedLines = append(selectedLines, "")
+			}
+			continue
+		}
+		if inLeadingBlockquote && !pastBlockquote {
+			pastBlockquote = true
+			if strings.TrimSpace(line) == "" {
+				continue
+			}
+		}
+		if pastBlockquote || (pastMeta && !inLeadingBlockquote) {
+			pastBlockquote = true
+			commentLines = append(commentLines, line)
+		}
+	}
+
+	if len(selectedLines) > 0 {
+		c.SelectedText = strings.Join(selectedLines, "\n")
+	}
+
+	comment := strings.TrimSpace(strings.Join(commentLines, "\n"))
+	comment = strings.TrimRight(comment, "\n")
+	if strings.HasSuffix(comment, "\n---") {
+		comment = strings.TrimSpace(comment[:len(comment)-4])
+	} else if comment == "---" {
+		comment = ""
+	}
+	c.Comment = comment
+
+	return c, true
+}
+
+func SerializeComments(cf CommentFile) []byte {
+	var b strings.Builder
+
+	b.WriteString("---\n")
+	b.WriteString("source: " + cf.Source + "\n")
+	b.WriteString("hash: " + cf.Hash + "\n")
+	fmt.Fprintf(&b, "version: %d\n", cf.Version)
+	b.WriteString("---\n\n")
+
+	for i, c := range cf.Comments {
+		fmt.Fprintf(&b, "<!-- c:%s|%s|%s -->\n", c.ID, c.LineHint, c.CreatedAt)
+
+		if c.AnchorPrefix != "" {
+			encoded := base64.StdEncoding.EncodeToString([]byte(c.AnchorPrefix))
+			fmt.Fprintf(&b, "<!-- anchor:%s -->\n", encoded)
+		}
+
+		for line := range strings.SplitSeq(c.SelectedText, "\n") {
+			b.WriteString("> " + line + "\n")
+		}
+
+		b.WriteString("\n")
+		b.WriteString(c.Comment)
+		b.WriteString("\n")
+
+		if i < len(cf.Comments)-1 {
+			b.WriteString("\n---\n\n")
+		}
+	}
+
+	return []byte(b.String())
+}
+
+func WriteCommentFile(path string, cf CommentFile) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return err
+	}
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, SerializeComments(cf), 0644); err != nil {
+		return err
+	}
+	return os.Rename(tmp, path)
+}
+
+func TruncateSelection(text string) string {
+	if utf8.RuneCountInString(text) <= MaxSelectionLength {
+		return text
+	}
+	runes := []rune(text)
+	half := (MaxSelectionLength - utf8.RuneCountInString(TruncationMarker)) / 2
+	return string(runes[:half]) + TruncationMarker + string(runes[len(runes)-half:])
+}
+
+func GetLineNumber(content string, offset int) int {
+	if offset <= 0 {
+		return 1
+	}
+	if offset > len(content) {
+		offset = len(content)
+	}
+	return strings.Count(content[:offset], "\n") + 1
+}
+
+func GetLineHint(content string, startOffset, endOffset int) string {
+	startLine := GetLineNumber(content, startOffset)
+	endLine := GetLineNumber(content, endOffset)
+	if startLine == endLine {
+		return fmt.Sprintf("L%d", startLine)
+	}
+	return fmt.Sprintf("L%d-L%d", startLine, endLine)
+}
+
+func NewCommentID() string {
+	b := make([]byte, 4)
+	if _, err := rand.Read(b); err != nil {
+		// Fallback to pseudo-random if crypto/rand fails
+		fallback := mrand.New(mrand.NewSource(time.Now().UnixNano()))
+		for i := range b {
+			b[i] = byte(fallback.Intn(256))
+		}
+	}
+	return fmt.Sprintf("%x", b)
+}
+
+func CreateComment(selectedText, commentText string, startOffset, endOffset int, sourceContent string) Comment {
+	truncated := TruncateSelection(selectedText)
+	c := Comment{
+		ID:           NewCommentID(),
+		SelectedText: truncated,
+		Comment:      strings.TrimSpace(commentText),
+		CreatedAt:    time.Now().UTC().Format(time.RFC3339Nano),
+		StartOffset:  startOffset,
+		EndOffset:    endOffset,
+		LineHint:     GetLineHint(sourceContent, startOffset, endOffset),
+	}
+	if utf8.RuneCountInString(selectedText) > MaxSelectionLength {
+		runes := []rune(selectedText)
+		c.AnchorPrefix = string(runes[:min(AnchorPrefixLength, len(runes))])
+	}
+	return c
+}

package/go/internal/server/storage_test.go

@@ -0,0 +1,152 @@
+package server
+
+import "testing"
+
+func TestComputeHash(t *testing.T) {
+	hash := ComputeHash([]byte("hello world"))
+	if len(hash) != HashLength {
+		t.Errorf("expected hash length %d, got %d", HashLength, len(hash))
+	}
+
+	hash2 := ComputeHash([]byte("hello world"))
+	if hash != hash2 {
+		t.Error("same input should produce same hash")
+	}
+
+	hash3 := ComputeHash([]byte("different"))
+	if hash == hash3 {
+		t.Error("different input should produce different hash")
+	}
+}
+
+func TestTruncateSelection(t *testing.T) {
+	short := "short text"
+	if TruncateSelection(short) != short {
+		t.Error("short text should not be truncated")
+	}
+
+	long := make([]byte, 2000)
+	for i := range long {
+		long[i] = 'a'
+	}
+	truncated := TruncateSelection(string(long))
+	if len(truncated) > MaxSelectionLength+10 {
+		t.Errorf("truncated length %d exceeds max %d", len(truncated), MaxSelectionLength)
+	}
+	if truncated[0] != 'a' {
+		t.Error("truncated should start with original content")
+	}
+	if truncated[len(truncated)-1] != 'a' {
+		t.Error("truncated should end with original content")
+	}
+}
+
+func TestGetLineNumber(t *testing.T) {
+	content := "line1\nline2\nline3"
+	if n := GetLineNumber(content, 0); n != 1 {
+		t.Errorf("offset 0: got line %d, want 1", n)
+	}
+	if n := GetLineNumber(content, 6); n != 2 {
+		t.Errorf("offset 6: got line %d, want 2", n)
+	}
+	if n := GetLineNumber(content, 12); n != 3 {
+		t.Errorf("offset 12: got line %d, want 3", n)
+	}
+}
+
+func TestGetLineHint(t *testing.T) {
+	content := "line1\nline2\nline3"
+	if h := GetLineHint(content, 0, 3); h != "L1" {
+		t.Errorf("same line: got %q, want L1", h)
+	}
+	if h := GetLineHint(content, 0, 12); h != "L1-L3" {
+		t.Errorf("multi line: got %q, want L1-L3", h)
+	}
+}
+
+func TestParseAndSerializeRoundTrip(t *testing.T) {
+	original := CommentFile{
+		Source:  "/path/to/file.md",
+		Hash:    "abcdef1234567890",
+		Version: 1,
+		Comments: []Comment{
+			{
+				ID:           "abc12345",
+				SelectedText: "hello world",
+				Comment:      "this is a comment",
+				CreatedAt:    "2026-03-27T00:00:00Z",
+				LineHint:     "L42",
+			},
+			{
+				ID:           "def67890",
+				SelectedText: "another selection",
+				Comment:      "second comment",
+				CreatedAt:    "2026-03-27T01:00:00Z",
+				LineHint:     "L55-L60",
+				AnchorPrefix: "another",
+			},
+		},
+	}
+
+	serialized := SerializeComments(original)
+	parsed, err := ParseCommentFile(serialized)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if parsed.Source != original.Source {
+		t.Errorf("source: got %q, want %q", parsed.Source, original.Source)
+	}
+	if parsed.Hash != original.Hash {
+		t.Errorf("hash: got %q, want %q", parsed.Hash, original.Hash)
+	}
+	if len(parsed.Comments) != len(original.Comments) {
+		t.Fatalf("comments: got %d, want %d", len(parsed.Comments), len(original.Comments))
+	}
+
+	for i := range original.Comments {
+		if parsed.Comments[i].ID != original.Comments[i].ID {
+			t.Errorf("comment %d ID: got %q, want %q", i, parsed.Comments[i].ID, original.Comments[i].ID)
+		}
+		if parsed.Comments[i].SelectedText != original.Comments[i].SelectedText {
+			t.Errorf("comment %d selectedText: got %q, want %q", i, parsed.Comments[i].SelectedText, original.Comments[i].SelectedText)
+		}
+		if parsed.Comments[i].Comment != original.Comments[i].Comment {
+			t.Errorf("comment %d comment: got %q, want %q", i, parsed.Comments[i].Comment, original.Comments[i].Comment)
+		}
+	}
+}
+
+func TestParseLegacyTwoFieldMarker(t *testing.T) {
+	legacy := []byte(`---
+source: /test.md
+hash: abc
+version: 1
+---
+
+<!-- c:abcd1234|L5 -->
+> selected text
+
+a comment body
+
+---
+`)
+
+	cf, err := ParseCommentFile(legacy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(cf.Comments) != 1 {
+		t.Fatalf("expected 1 comment from legacy 2-field marker, got %d", len(cf.Comments))
+	}
+	c := cf.Comments[0]
+	if c.ID != "abcd1234" {
+		t.Errorf("ID: got %q, want %q", c.ID, "abcd1234")
+	}
+	if c.LineHint != "L5" {
+		t.Errorf("LineHint: got %q, want %q", c.LineHint, "L5")
+	}
+	if c.CreatedAt != "" {
+		t.Errorf("CreatedAt: got %q, want empty string", c.CreatedAt)
+	}
+}

package/go/internal/server/template.go

@@ -0,0 +1,66 @@
+package server
+
+import (
+	"encoding/json"
+	"html/template"
+	"strings"
+)
+
+type TemplateData struct {
+	Title        string
+	CSSPath      string
+	JSPath       string
+	DocumentHTML template.HTML
+	InlineJSON   template.JS
+	IsDev        bool
+	FontFamily   string
+	ProseClass   string
+	ViteClient   template.HTML
+}
+
+const pageTemplate = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>readit — {{.Title}}</title>
+  <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>📖</text></svg>">
+  <script>
+    (() => {
+      var t = localStorage.getItem("readit:theme");
+      var d = t === "dark" || (t !== "light" && matchMedia("(prefers-color-scheme: dark)").matches);
+      if (d) document.documentElement.classList.add("dark");
+    })();
+  </script>
+  {{.ViteClient}}
+  {{if .CSSPath}}<link rel="stylesheet" href="{{.CSSPath}}">{{end}}
+</head>
+<body class="min-h-screen">
+  <article id="document-content" class="prose {{.ProseClass}}">{{.DocumentHTML}}</article>
+  <div id="app"></div>
+  <script type="application/json" id="__readit">{{.InlineJSON}}</script>
+  <script type="module" src="{{.JSPath}}"></script>
+</body>
+</html>`
+
+func CompileTemplate() *template.Template {
+	return template.Must(template.New("page").Parse(pageTemplate))
+}
+
+func RenderPage(tmpl *template.Template, data TemplateData) (string, error) {
+	var b strings.Builder
+	if err := tmpl.Execute(&b, data); err != nil {
+		return "", err
+	}
+	return b.String(), nil
+}
+
+// SafeJSONStringify serializes data for embedding in a <script> tag.
+func SafeJSONStringify(data any) (template.JS, error) {
+	b, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	s := strings.ReplaceAll(string(b), "<", `\u003c`)
+	return template.JS(s), nil
+}