@peaske7/readit 0.2.0 → 0.3.0-rc.0

package/go/internal/server/comments.go

@@ -0,0 +1,390 @@
+package server
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+)
+
+func (s *Server) commentLock(path string) *sync.Mutex {
+	s.commentFileMu.Lock()
+	defer s.commentFileMu.Unlock()
+	mu, ok := s.commentFileLocks[path]
+	if !ok {
+		mu = &sync.Mutex{}
+		s.commentFileLocks[path] = mu
+	}
+	return mu
+}
+
+func (s *Server) resolveCommentsFor(path string, state *FileState) []Comment {
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		log.Printf("Warning: failed to resolve comment path for %s: %v", path, err)
+		return []Comment{}
+	}
+
+	s.commentCacheMu.RLock()
+	cached := s.commentCache[path]
+	s.commentCacheMu.RUnlock()
+
+	sourceHash := ComputeHash(state.Content)
+
+	info, err := os.Stat(commentPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return []Comment{}
+		}
+		log.Printf("Warning: unexpected error checking comment file %s: %v", commentPath, err)
+		return []Comment{}
+	}
+
+	mtimeMs := info.ModTime().UnixMilli()
+	if cached != nil && cached.sourceHash == sourceHash && cached.commentMtimeMs == mtimeMs {
+		return cached.comments
+	}
+
+	data, err := os.ReadFile(commentPath)
+	if err != nil {
+		return []Comment{}
+	}
+
+	cf, err := ParseCommentFile(data)
+	if err != nil {
+		return []Comment{}
+	}
+
+	sourceContent := string(state.Content)
+	domText := ExtractTextFromHTML(state.RenderedHTML)
+
+	resolved := make([]Comment, 0, len(cf.Comments))
+	for _, c := range cf.Comments {
+		searchText := c.SelectedText
+		if c.AnchorPrefix != "" {
+			searchText = c.AnchorPrefix
+		}
+
+		result := FindAnchorWithFallback(sourceContent, searchText, c.LineHint)
+		if result != nil {
+			c.StartOffset = result.StartOffset
+			c.EndOffset = result.EndOffset
+			c.AnchorConfidence = result.Confidence
+
+			if start, end, ok := FindTextPosition(domText, searchText, result.StartOffset); ok {
+				c.StartOffset = start
+				c.EndOffset = end
+			}
+		} else {
+			c.AnchorConfidence = AnchorUnresolved
+		}
+
+		resolved = append(resolved, c)
+	}
+
+	s.commentCacheMu.Lock()
+	s.commentCache[path] = &resolvedCacheEntry{
+		commentMtimeMs: mtimeMs,
+		sourceHash:     sourceHash,
+		comments:       resolved,
+	}
+	s.commentCacheMu.Unlock()
+
+	return resolved
+}
+
+func (s *Server) listComments(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+	state := s.getFileState(path)
+	if state == nil {
+		writeError(w, http.StatusNotFound, "document not found")
+		return
+	}
+
+	comments := s.resolveCommentsFor(path, state)
+	writeJSON(w, http.StatusOK, map[string]any{"comments": comments})
+}
+
+func (s *Server) createComment(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+	state := s.getFileState(path)
+	if state == nil {
+		writeError(w, http.StatusNotFound, "document not found")
+		return
+	}
+
+	var body struct {
+		SelectedText string `json:"selectedText"`
+		Comment      string `json:"comment"`
+		StartOffset  int    `json:"startOffset"`
+		EndOffset    int    `json:"endOffset"`
+	}
+	if err := readJSON(r, &body); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+
+	if body.SelectedText == "" || body.Comment == "" {
+		writeError(w, http.StatusBadRequest, "selectedText and comment are required")
+		return
+	}
+
+	c := CreateComment(body.SelectedText, body.Comment, body.StartOffset, body.EndOffset, string(state.Content))
+
+	mu := s.commentLock(path)
+	mu.Lock()
+	defer mu.Unlock()
+
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to resolve comment path: %v", err))
+		return
+	}
+	cf := CommentFile{
+		Source:  path,
+		Hash:    ComputeHash(state.Content),
+		Version: FormatVersion,
+	}
+
+	if data, err := os.ReadFile(commentPath); err == nil {
+		parsed, parseErr := ParseCommentFile(data)
+		if parseErr != nil {
+			writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to parse existing comment file: %v", parseErr))
+			return
+		}
+		cf = parsed
+	} else if !os.IsNotExist(err) {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to read comment file: %v", err))
+		return
+	}
+	cf.Hash = ComputeHash(state.Content)
+	cf.Comments = append(cf.Comments, c)
+
+	if err := WriteCommentFile(commentPath, cf); err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to save comment: %v", err))
+		return
+	}
+	s.invalidateCommentCache(path)
+
+	writeJSON(w, http.StatusCreated, map[string]any{"comment": c})
+}
+
+func (s *Server) updateComment(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+	commentID := r.PathValue("id")
+
+	var body struct {
+		Comment string `json:"comment"`
+	}
+	if err := readJSON(r, &body); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+
+	mu := s.commentLock(path)
+	mu.Lock()
+	defer mu.Unlock()
+
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to resolve comment path: %v", err))
+		return
+	}
+	data, err := os.ReadFile(commentPath)
+	if err != nil {
+		writeError(w, http.StatusNotFound, fmt.Sprintf("comment file not found: %v", err))
+		return
+	}
+
+	cf, err := ParseCommentFile(data)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to parse comments: %v", err))
+		return
+	}
+
+	for i := range cf.Comments {
+		if cf.Comments[i].ID == commentID {
+			cf.Comments[i].Comment = strings.TrimSpace(body.Comment)
+
+			if err := WriteCommentFile(commentPath, cf); err != nil {
+				writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to save: %v", err))
+				return
+			}
+			s.invalidateCommentCache(path)
+			writeJSON(w, http.StatusOK, map[string]any{"comment": cf.Comments[i]})
+			return
+		}
+	}
+
+	writeError(w, http.StatusNotFound, "comment not found")
+}
+
+func (s *Server) deleteComment(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+	commentID := r.PathValue("id")
+
+	mu := s.commentLock(path)
+	mu.Lock()
+	defer mu.Unlock()
+
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to resolve comment path: %v", err))
+		return
+	}
+	data, err := os.ReadFile(commentPath)
+	if err != nil {
+		writeError(w, http.StatusNotFound, fmt.Sprintf("comment file not found: %v", err))
+		return
+	}
+
+	cf, err := ParseCommentFile(data)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to parse comments: %v", err))
+		return
+	}
+
+	filtered := make([]Comment, 0, len(cf.Comments))
+	for _, c := range cf.Comments {
+		if c.ID != commentID {
+			filtered = append(filtered, c)
+		}
+	}
+
+	if len(filtered) == len(cf.Comments) {
+		writeError(w, http.StatusNotFound, "comment not found")
+		return
+	}
+
+	if len(filtered) == 0 {
+		if err := os.Remove(commentPath); err != nil && !os.IsNotExist(err) {
+			writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to delete comment file: %v", err))
+			return
+		}
+	} else {
+		cf.Comments = filtered
+		if err := WriteCommentFile(commentPath, cf); err != nil {
+			writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to save comments: %v", err))
+			return
+		}
+	}
+	s.invalidateCommentCache(path)
+
+	writeJSON(w, http.StatusOK, map[string]bool{"success": true})
+}
+
+func (s *Server) deleteAllComments(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+
+	mu := s.commentLock(path)
+	mu.Lock()
+	defer mu.Unlock()
+
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to resolve comment path: %v", err))
+		return
+	}
+	if err := os.Remove(commentPath); err != nil && !os.IsNotExist(err) {
+		writeError(w, http.StatusInternalServerError, "failed to delete comment file")
+		return
+	}
+	s.invalidateCommentCache(path)
+	writeJSON(w, http.StatusOK, map[string]bool{"success": true})
+}
+
+func (s *Server) reanchorComment(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+	state := s.getFileState(path)
+	if state == nil {
+		writeError(w, http.StatusNotFound, "document not found")
+		return
+	}
+
+	commentID := r.PathValue("id")
+
+	var body struct {
+		SelectedText string `json:"selectedText"`
+		StartOffset  int    `json:"startOffset"`
+		EndOffset    int    `json:"endOffset"`
+	}
+	if err := readJSON(r, &body); err != nil {
+		writeError(w, http.StatusBadRequest, "invalid request body")
+		return
+	}
+
+	mu := s.commentLock(path)
+	mu.Lock()
+	defer mu.Unlock()
+
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to resolve comment path: %v", err))
+		return
+	}
+	data, err := os.ReadFile(commentPath)
+	if err != nil {
+		writeError(w, http.StatusNotFound, fmt.Sprintf("comment file not found: %v", err))
+		return
+	}
+
+	cf, err := ParseCommentFile(data)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to parse comments: %v", err))
+		return
+	}
+
+	sourceContent := string(state.Content)
+	for i := range cf.Comments {
+		if cf.Comments[i].ID == commentID {
+			truncated := TruncateSelection(body.SelectedText)
+			cf.Comments[i].SelectedText = truncated
+			cf.Comments[i].StartOffset = body.StartOffset
+			cf.Comments[i].EndOffset = body.EndOffset
+			cf.Comments[i].LineHint = GetLineHint(sourceContent, body.StartOffset, body.EndOffset)
+			cf.Comments[i].AnchorConfidence = AnchorExact
+
+			if len(body.SelectedText) > MaxSelectionLength {
+				cf.Comments[i].AnchorPrefix = body.SelectedText[:min(AnchorPrefixLength, len(body.SelectedText))]
+			} else {
+				cf.Comments[i].AnchorPrefix = ""
+			}
+
+			cf.Hash = ComputeHash(state.Content)
+			if err := WriteCommentFile(commentPath, cf); err != nil {
+				writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to save: %v", err))
+				return
+			}
+			s.invalidateCommentCache(path)
+			writeJSON(w, http.StatusOK, map[string]any{"comment": cf.Comments[i]})
+			return
+		}
+	}
+
+	writeError(w, http.StatusNotFound, "comment not found")
+}
+
+func (s *Server) rawComments(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+	commentPath, err := CommentPath(path)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, fmt.Sprintf("failed to resolve comment path: %v", err))
+		return
+	}
+
+	data, err := os.ReadFile(commentPath)
+	if err != nil {
+		writeJSON(w, http.StatusOK, map[string]any{
+			"content": nil,
+			"path":    commentPath,
+		})
+		return
+	}
+
+	writeJSON(w, http.StatusOK, map[string]any{
+		"content": string(data),
+		"path":    commentPath,
+	})
+}

package/go/internal/server/documents.go

@@ -0,0 +1,113 @@
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+
+func (s *Server) listDocuments(w http.ResponseWriter, r *http.Request) {
+	s.mu.RLock()
+	files := make([]FileRef, 0, len(s.fileOrder))
+	for _, p := range s.fileOrder {
+		if f, ok := s.files[p]; ok {
+			files = append(files, FileRef{Path: p, FileName: f.FileName})
+		}
+	}
+	clean := s.clean
+	workingDir := s.workingDir
+	s.mu.RUnlock()
+
+	writeJSON(w, http.StatusOK, map[string]any{
+		"files":            files,
+		"clean":            clean,
+		"workingDirectory": workingDir,
+	})
+}
+
+func (s *Server) addDocument(w http.ResponseWriter, r *http.Request) {
+	var body struct {
+		Path string `json:"path"`
+	}
+	if err := readJSON(r, &body); err != nil || body.Path == "" {
+		writeError(w, http.StatusBadRequest, "path is required")
+		return
+	}
+
+	absPath, err := filepath.Abs(body.Path)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid path")
+		return
+	}
+	absPath, err = filepath.EvalSymlinks(absPath)
+	if err != nil {
+		writeError(w, http.StatusNotFound, "file not found")
+		return
+	}
+
+	if !isMarkdownFile(absPath) {
+		writeError(w, http.StatusBadRequest, "only markdown files are supported")
+		return
+	}
+
+	s.mu.RLock()
+	_, exists := s.files[absPath]
+	s.mu.RUnlock()
+
+	if exists {
+		writeJSON(w, http.StatusOK, map[string]string{
+			"path":     absPath,
+			"fileName": filepath.Base(absPath),
+			"status":   "present",
+		})
+		return
+	}
+
+	if err := s.loadFile(FileEntry{FilePath: absPath}); err != nil {
+		writeError(w, http.StatusInternalServerError, "failed to load file")
+		return
+	}
+
+	fileName := filepath.Base(absPath)
+
+	event, _ := json.Marshal(map[string]string{
+		"type":     "document-added",
+		"path":     absPath,
+		"fileName": fileName,
+	})
+	s.sse.Broadcast(string(event))
+
+	writeJSON(w, http.StatusOK, map[string]string{
+		"path":     absPath,
+		"fileName": fileName,
+		"status":   "added",
+	})
+}
+
+func (s *Server) getDocument(w http.ResponseWriter, r *http.Request) {
+	path := s.resolveFilePath(r)
+
+	s.mu.RLock()
+	state := s.files[path]
+	clean := s.clean
+	s.mu.RUnlock()
+
+	if state == nil {
+		writeError(w, http.StatusNotFound, "document not found")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, map[string]any{
+		"html":     state.RenderedHTML,
+		"headings": state.Headings,
+		"filePath": state.FilePath,
+		"fileName": state.FileName,
+		"clean":    clean,
+	})
+}
+
+func isMarkdownFile(path string) bool {
+	ext := strings.ToLower(filepath.Ext(path))
+	return ext == ".md" || ext == ".markdown"
+}

package/go/internal/server/embed.go

@@ -0,0 +1,17 @@
+package server
+
+import (
+	"embed"
+	"io/fs"
+)
+
+//go:embed all:dist
+var embeddedAssets embed.FS
+
+func EmbeddedAssetsFS() fs.FS {
+	sub, err := fs.Sub(embeddedAssets, "dist")
+	if err != nil {
+		return nil
+	}
+	return sub
+}

package/go/internal/server/headings.go

@@ -0,0 +1,33 @@
+package server
+
+import (
+	"bytes"
+	"strings"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/parser"
+	"github.com/yuin/goldmark/text"
+)
+
+// ExtractHeadings parses markdown source and returns headings using goldmark's AST.
+// This ensures heading IDs match exactly what goldmark renders in HTML.
+func ExtractHeadings(source []byte) []Heading {
+	md := goldmark.New(
+		goldmark.WithParserOptions(
+			parser.WithAutoHeadingID(),
+		),
+	)
+
+	reader := text.NewReader(source)
+	doc := md.Parser().Parse(reader)
+
+	return extractHeadingsFromAST(doc, source)
+}
+
+// collectHeadingText recursively collects plain text from heading AST nodes.
+func collectHeadingText(n ast.Node, source []byte) string {
+	var buf bytes.Buffer
+	collectText(n, source, &buf)
+	return strings.TrimSpace(buf.String())
+}

package/go/internal/server/headings_test.go

@@ -0,0 +1,75 @@
+package server
+
+import "testing"
+
+func TestExtractHeadingsDeduplicate(t *testing.T) {
+	src := []byte("# Title\n\n## Title\n\n### Title\n")
+	headings := ExtractHeadings(src)
+
+	if len(headings) != 3 {
+		t.Fatalf("expected 3 headings, got %d", len(headings))
+	}
+
+	if headings[0].ID != "title" {
+		t.Errorf("heading 0 ID = %q, want %q", headings[0].ID, "title")
+	}
+	if headings[1].ID != "title-1" {
+		t.Errorf("heading 1 ID = %q, want %q", headings[1].ID, "title-1")
+	}
+	if headings[2].ID != "title-2" {
+		t.Errorf("heading 2 ID = %q, want %q", headings[2].ID, "title-2")
+	}
+}
+
+func TestExtractHeadingsSkipsCodeBlocks(t *testing.T) {
+	src := []byte("# Real Heading\n\n```\n# Not a heading\n```\n\n## Another Real\n")
+	headings := ExtractHeadings(src)
+
+	if len(headings) != 2 {
+		t.Fatalf("expected 2 headings, got %d", len(headings))
+	}
+
+	if headings[0].Text != "Real Heading" {
+		t.Errorf("heading 0 text = %q", headings[0].Text)
+	}
+	if headings[1].Text != "Another Real" {
+		t.Errorf("heading 1 text = %q", headings[1].Text)
+	}
+}
+
+func TestExtractHeadingsLevels(t *testing.T) {
+	src := []byte("# H1\n## H2\n### H3\n#### H4\n##### H5\n###### H6\n")
+	headings := ExtractHeadings(src)
+
+	if len(headings) != 6 {
+		t.Fatalf("expected 6 headings, got %d", len(headings))
+	}
+
+	for i, h := range headings {
+		if h.Level != i+1 {
+			t.Errorf("heading %d level = %d, want %d", i, h.Level, i+1)
+		}
+	}
+}
+
+func TestExtractHeadingsSetextStyle(t *testing.T) {
+	src := []byte("Setext H1\n=========\n\nSetext H2\n---------\n")
+	headings := ExtractHeadings(src)
+
+	if len(headings) != 2 {
+		t.Fatalf("expected 2 headings, got %d", len(headings))
+	}
+
+	if headings[0].Text != "Setext H1" {
+		t.Errorf("heading 0 text = %q, want %q", headings[0].Text, "Setext H1")
+	}
+	if headings[0].Level != 1 {
+		t.Errorf("heading 0 level = %d, want 1", headings[0].Level)
+	}
+	if headings[1].Text != "Setext H2" {
+		t.Errorf("heading 1 text = %q, want %q", headings[1].Text, "Setext H2")
+	}
+	if headings[1].Level != 2 {
+		t.Errorf("heading 1 level = %d, want 2", headings[1].Level)
+	}
+}