@peaske7/readit 0.2.1 → 0.3.0-rc.1

package/go/internal/server/sse.go

@@ -1,140 +0,0 @@
-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

@@ -1,275 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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)
-		}
-	}
-}

package/go/internal/server/template.go

@@ -1,66 +0,0 @@
-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
-}

package/go/internal/server/types.go

@@ -1,101 +0,0 @@
-package server
-
-type Comment struct {
-	ID               string `json:"id"`
-	SelectedText     string `json:"selectedText"`
-	Comment          string `json:"comment"`
-	CreatedAt        string `json:"createdAt"`
-	StartOffset      int    `json:"startOffset"`
-	EndOffset        int    `json:"endOffset"`
-	LineHint         string `json:"lineHint,omitempty"`
-	AnchorConfidence string `json:"anchorConfidence,omitempty"`
-	AnchorPrefix     string `json:"anchorPrefix,omitempty"`
-}
-
-type Heading struct {
-	ID    string `json:"id"`
-	Text  string `json:"text"`
-	Level int    `json:"level"`
-}
-
-type FileState struct {
-	FilePath     string
-	FileName     string
-	Content      []byte
-	RenderedHTML string
-	Headings     []Heading
-	IsLoaded     bool
-}
-
-type ShortcutBinding struct {
-	Key   string `json:"key"`
-	Alt   bool   `json:"alt,omitempty"`
-	Ctrl  bool   `json:"ctrl,omitempty"`
-	Meta  bool   `json:"meta,omitempty"`
-	Shift bool   `json:"shift,omitempty"`
-}
-
-type Keybinding struct {
-	ID      string           `json:"id"`
-	Binding *ShortcutBinding `json:"binding,omitempty"`
-	Enabled bool             `json:"enabled"`
-}
-
-type Settings struct {
-	Version     int          `json:"version"`
-	FontFamily  string       `json:"fontFamily"`
-	Keybindings []Keybinding `json:"keybindings,omitempty"`
-}
-
-type CommentFile struct {
-	Source   string
-	Hash     string
-	Version  int
-	Comments []Comment
-}
-
-type InlineData struct {
-	Files      []FileRef                `json:"files"`
-	ActiveFile string                   `json:"activeFile"`
-	Clean      bool                     `json:"clean"`
-	WorkingDir string                   `json:"workingDirectory"`
-	Documents  map[string]InlineDocData `json:"documents"`
-	Settings   Settings                 `json:"settings"`
-}
-
-type FileRef struct {
-	Path     string `json:"path"`
-	FileName string `json:"fileName"`
-}
-
-type InlineDocData struct {
-	Headings []Heading `json:"headings"`
-	Comments []Comment `json:"comments"`
-}
-
-const (
-	AnchorExact      = "exact"
-	AnchorNormalized = "normalized"
-	AnchorFuzzy      = "fuzzy"
-	AnchorUnresolved = "unresolved"
-)
-
-const (
-	FontSerif     = "serif"
-	FontSansSerif = "sans-serif"
-)
-
-const (
-	FormatVersion      = 1
-	HashLength         = 16
-	MaxSelectionLength = 1000
-	TruncationMarker   = "\n...\n"
-	AnchorPrefixLength = 200
-)
-
-const (
-	DefaultSearchWindow   = 500
-	DefaultFuzzyThreshold = 5
-	MaxFuzzyTextLength    = 200
-	FuzzySearchWindow     = 2000
-)