@peaske7/readit 0.2.1 → 0.3.0-rc.1

package/go/internal/server/comments.go

@@ -1,390 +0,0 @@
-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, "failed to resolve comment path")
-		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, "failed to resolve comment path")
-		return
-	}
-	data, err := os.ReadFile(commentPath)
-	if err != nil {
-		writeError(w, http.StatusNotFound, "comment file not found")
-		return
-	}
-
-	cf, err := ParseCommentFile(data)
-	if err != nil {
-		writeError(w, http.StatusInternalServerError, "failed to parse comments")
-		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, "failed to save")
-				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, "failed to resolve comment path")
-		return
-	}
-	data, err := os.ReadFile(commentPath)
-	if err != nil {
-		writeError(w, http.StatusNotFound, "comment file not found")
-		return
-	}
-
-	cf, err := ParseCommentFile(data)
-	if err != nil {
-		writeError(w, http.StatusInternalServerError, "failed to parse comments")
-		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, "failed to delete comment file")
-			return
-		}
-	} else {
-		cf.Comments = filtered
-		if err := WriteCommentFile(commentPath, cf); err != nil {
-			writeError(w, http.StatusInternalServerError, "failed to save comments")
-			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, "failed to resolve comment path")
-		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, "failed to resolve comment path")
-		return
-	}
-	data, err := os.ReadFile(commentPath)
-	if err != nil {
-		writeError(w, http.StatusNotFound, "comment file not found")
-		return
-	}
-
-	cf, err := ParseCommentFile(data)
-	if err != nil {
-		writeError(w, http.StatusInternalServerError, "failed to parse comments")
-		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, "failed to save")
-				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, "failed to resolve comment path")
-		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

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

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

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

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