@peaske7/readit 0.3.0-rc.0 → 0.3.0-rc.2

package/go/internal/server/server.go

@@ -1,453 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"fmt"
-	"html/template"
-	"io/fs"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-	"path/filepath"
-	"sync"
-)
-
-// Options configures the server.
-type Options struct {
-	Files      []FileEntry
-	Port       int
-	Host       string
-	Clean      bool
-	AssetsDir  string
-	Dev        bool
-	OnShutdown func()
-}
-
-type FileEntry struct {
-	FilePath string
-	Content  []byte
-}
-
-type Server struct {
-	mux        *http.ServeMux
-	files      map[string]*FileState
-	fileOrder  []string
-	sse        *SSEBroker
-	watcher    *Watcher
-	renderer   *Renderer
-	settings   Settings
-	workingDir string
-	clean      bool
-	assetsFS   fs.FS
-	tmpl       *template.Template
-	isDev      bool
-	viteProxy  http.Handler
-	mu         sync.RWMutex
-
-	commentCache   map[string]*resolvedCacheEntry
-	commentCacheMu sync.RWMutex
-
-	commentFileMu    sync.Mutex
-	commentFileLocks map[string]*sync.Mutex
-
-	httpServer *http.Server
-}
-
-type resolvedCacheEntry struct {
-	commentMtimeMs int64
-	sourceHash     string
-	comments       []Comment
-}
-
-func NewServer(opts Options) (*Server, error) {
-	wd, err := os.Getwd()
-	if err != nil {
-		wd = "."
-	}
-
-	s := &Server{
-		mux:              http.NewServeMux(),
-		files:            make(map[string]*FileState),
-		renderer:         NewRenderer(),
-		settings:         DefaultSettings(),
-		workingDir:       wd,
-		clean:            opts.Clean,
-		tmpl:             CompileTemplate(),
-		isDev:            opts.Dev,
-		commentCache:     make(map[string]*resolvedCacheEntry),
-		commentFileLocks: make(map[string]*sync.Mutex),
-	}
-
-	if loaded, err := ReadSettings(); err == nil {
-		s.settings = loaded
-	}
-
-	s.sse = NewSSEBroker(opts.Dev, opts.OnShutdown)
-
-	w, err := NewWatcher(func(path string) {
-		s.onFileChange(path)
-	})
-	if err != nil {
-		return nil, fmt.Errorf("watcher: %w", err)
-	}
-	s.watcher = w
-
-	if opts.AssetsDir != "" {
-		s.assetsFS = os.DirFS(opts.AssetsDir)
-	} else if !opts.Dev {
-		s.assetsFS = EmbeddedAssetsFS()
-	}
-
-	if opts.Dev {
-		viteURL, _ := url.Parse("http://127.0.0.1:24678")
-		s.viteProxy = httputil.NewSingleHostReverseProxy(viteURL)
-	}
-
-	for _, f := range opts.Files {
-		if err := s.loadFile(f); err != nil {
-			log.Printf("Warning: failed to load %s: %v", f.FilePath, err)
-		}
-	}
-
-	s.registerRoutes()
-
-	return s, nil
-}
-
-func (s *Server) registerRoutes() {
-	s.mux.HandleFunc("GET /api/documents", s.listDocuments)
-	s.mux.HandleFunc("POST /api/documents", s.addDocument)
-	s.mux.HandleFunc("GET /api/document", s.getDocument)
-
-	s.mux.HandleFunc("GET /api/comments/raw", s.rawComments)
-	s.mux.HandleFunc("GET /api/comments", s.listComments)
-	s.mux.HandleFunc("POST /api/comments", s.createComment)
-	s.mux.HandleFunc("PUT /api/comments/{id}/reanchor", s.reanchorComment)
-	s.mux.HandleFunc("PUT /api/comments/{id}", s.updateComment)
-	s.mux.HandleFunc("DELETE /api/comments/{id}", s.deleteComment)
-	s.mux.HandleFunc("DELETE /api/comments", s.deleteAllComments)
-
-	s.mux.HandleFunc("GET /api/settings", s.getSettings)
-	s.mux.HandleFunc("PUT /api/settings", s.updateSettings)
-
-	s.mux.HandleFunc("GET /api/document/stream", s.sse.DocumentStream)
-	s.mux.HandleFunc("GET /api/heartbeat", s.sse.Heartbeat)
-
-	s.mux.HandleFunc("GET /api/health", func(w http.ResponseWriter, r *http.Request) {
-		writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
-	})
-
-	s.mux.HandleFunc("GET /{$}", s.servePage)
-
-	if s.assetsFS != nil {
-		s.mux.Handle("GET /assets/", http.FileServer(http.FS(s.assetsFS)))
-	}
-
-	if s.isDev && s.viteProxy != nil {
-		s.mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
-			s.viteProxy.ServeHTTP(w, r)
-		})
-	}
-}
-
-func (s *Server) Start(host string, port int) (int, error) {
-	for p := port; p <= 65535; p++ {
-		addr := fmt.Sprintf("%s:%d", host, p)
-		ln, err := net.Listen("tcp", addr)
-		if err != nil {
-			if p < 65535 {
-				log.Printf("Port %d is busy, trying %d...", p, p+1)
-				continue
-			}
-			return 0, fmt.Errorf("no available port found")
-		}
-
-		s.httpServer = &http.Server{Handler: s.mux}
-		log.Printf("Server listening on http://%s", addr)
-
-		go func() {
-			if err := s.httpServer.Serve(ln); err != nil && err != http.ErrServerClosed {
-				log.Printf("HTTP server error: %v", err)
-			}
-		}()
-
-		return p, nil
-	}
-	return 0, fmt.Errorf("no available port")
-}
-
-func (s *Server) Stop() {
-	if s.httpServer != nil {
-		_ = s.httpServer.Close()
-	}
-	s.watcher.Close()
-}
-
-func (s *Server) loadFile(f FileEntry) error {
-	absPath, err := filepath.Abs(f.FilePath)
-	if err != nil {
-		return err
-	}
-	absPath, err = filepath.EvalSymlinks(absPath)
-	if err != nil {
-		return err
-	}
-
-	content := f.Content
-	if content == nil {
-		data, err := os.ReadFile(absPath)
-		if err != nil {
-			return err
-		}
-		content = data
-	}
-
-	result, err := s.renderer.Render(content)
-	if err != nil {
-		return err
-	}
-
-	s.mu.Lock()
-	_, alreadyExists := s.files[absPath]
-	s.files[absPath] = &FileState{
-		FilePath:     absPath,
-		FileName:     filepath.Base(absPath),
-		Content:      content,
-		RenderedHTML: result.HTML,
-		Headings:     result.Headings,
-		IsLoaded:     true,
-	}
-	if !alreadyExists {
-		s.fileOrder = append(s.fileOrder, absPath)
-	}
-	s.mu.Unlock()
-
-	if err := s.watcher.Add(absPath); err != nil {
-		log.Printf("Warning: failed to watch %s: %v", absPath, err)
-	}
-	return nil
-}
-
-func (s *Server) onFileChange(path string) {
-	s.mu.RLock()
-	_, ok := s.files[path]
-	s.mu.RUnlock()
-	if !ok {
-		return
-	}
-
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return
-	}
-	result, err := s.renderer.Render(data)
-	if err != nil {
-		return
-	}
-
-	s.mu.Lock()
-	state, ok := s.files[path]
-	if ok {
-		state.Content = data
-		state.RenderedHTML = result.HTML
-		state.Headings = result.Headings
-	}
-	s.mu.Unlock()
-
-	if !ok {
-		return
-	}
-
-	s.invalidateCommentCache(path)
-
-	jsonEvent, _ := json.Marshal(map[string]string{
-		"type": "document-updated",
-		"path": path,
-	})
-	s.sse.Broadcast(string(jsonEvent))
-}
-
-func (s *Server) invalidateCommentCache(path string) {
-	s.commentCacheMu.Lock()
-	delete(s.commentCache, path)
-	s.commentCacheMu.Unlock()
-}
-
-func (s *Server) defaultFilePath() string {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	if len(s.fileOrder) > 0 {
-		return s.fileOrder[0]
-	}
-	return ""
-}
-
-func (s *Server) resolveFilePath(r *http.Request) string {
-	if p := r.URL.Query().Get("path"); p != "" {
-		if abs, err := filepath.Abs(p); err == nil {
-			if resolved, err := filepath.EvalSymlinks(abs); err == nil {
-				return resolved
-			}
-		}
-		return p
-	}
-	return s.defaultFilePath()
-}
-
-func (s *Server) getFileState(path string) *FileState {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.files[path]
-}
-
-func (s *Server) servePage(w http.ResponseWriter, r *http.Request) {
-	s.mu.RLock()
-	var defaultPath string
-	if len(s.fileOrder) > 0 {
-		defaultPath = s.fileOrder[0]
-	}
-	state := s.files[defaultPath]
-
-	if state == nil {
-		s.mu.RUnlock()
-		http.Error(w, "no document loaded", http.StatusNotFound)
-		return
-	}
-
-	// Collect file data under the read lock, but resolve comments after releasing it
-	type fileSnapshot struct {
-		path         string
-		content      []byte
-		renderedHTML string
-		headings     []Heading
-	}
-	snapshots := make([]fileSnapshot, 0, len(s.files))
-	for path, fs := range s.files {
-		snapshots = append(snapshots, fileSnapshot{
-			path:         path,
-			content:      fs.Content,
-			renderedHTML: fs.RenderedHTML,
-			headings:     fs.Headings,
-		})
-	}
-
-	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})
-		}
-	}
-
-	stateFileName := state.FileName
-	stateRenderedHTML := state.RenderedHTML
-	clean := s.clean
-	workingDir := s.workingDir
-	settings := s.settings
-	s.mu.RUnlock()
-
-	// Resolve comments outside the main lock to avoid nested locking
-	docs := make(map[string]InlineDocData)
-	for _, snap := range snapshots {
-		comments := s.resolveCommentsFor(snap.path, &FileState{
-			Content:      snap.content,
-			RenderedHTML: snap.renderedHTML,
-		})
-		docs[snap.path] = InlineDocData{
-			Headings: snap.headings,
-			Comments: comments,
-		}
-	}
-
-	inline := InlineData{
-		Files:      files,
-		ActiveFile: defaultPath,
-		Clean:      clean,
-		WorkingDir: workingDir,
-		Documents:  docs,
-		Settings:   settings,
-	}
-
-	inlineJSON, err := SafeJSONStringify(inline)
-	if err != nil {
-		http.Error(w, "failed to serialize data", http.StatusInternalServerError)
-		return
-	}
-
-	jsPath, cssPath := s.resolveAssetPaths()
-
-	proseClass := "prose-serif"
-	if settings.FontFamily == FontSansSerif {
-		proseClass = "prose-sans"
-	}
-
-	var viteClient template.HTML
-	if s.isDev {
-		viteClient = `<script type="module" src="http://127.0.0.1:24678/@vite/client"></script>`
-	}
-
-	data := TemplateData{
-		Title:        stateFileName,
-		CSSPath:      cssPath,
-		JSPath:       jsPath,
-		DocumentHTML: template.HTML(stateRenderedHTML),
-		InlineJSON:   inlineJSON,
-		IsDev:        s.isDev,
-		FontFamily:   settings.FontFamily,
-		ProseClass:   proseClass,
-		ViteClient:   viteClient,
-	}
-
-	page, err := RenderPage(s.tmpl, data)
-	if err != nil {
-		http.Error(w, "template error", http.StatusInternalServerError)
-		return
-	}
-
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	_, _ = w.Write([]byte(page))
-}
-
-func (s *Server) resolveAssetPaths() (jsPath, cssPath string) {
-	if s.isDev {
-		return "http://127.0.0.1:24678/src/main.ts", ""
-	}
-
-	if s.assetsFS != nil {
-		data, err := fs.ReadFile(s.assetsFS, ".vite/manifest.json")
-		if err == nil {
-			var manifest map[string]struct {
-				File string   `json:"file"`
-				CSS  []string `json:"css"`
-			}
-			if json.Unmarshal(data, &manifest) == nil {
-				if entry, ok := manifest["index.html"]; ok {
-					jsPath = "/" + entry.File
-					if len(entry.CSS) > 0 {
-						cssPath = "/" + entry.CSS[0]
-					}
-					return
-				}
-			}
-		}
-	}
-
-	return "/assets/index.js", ""
-}
-
-func writeJSON(w http.ResponseWriter, status int, data any) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(status)
-	_ = json.NewEncoder(w).Encode(data)
-}
-
-func writeError(w http.ResponseWriter, status int, msg string) {
-	writeJSON(w, status, map[string]string{"error": msg})
-}
-
-func readJSON(r *http.Request, v any) error {
-	defer func() { _ = r.Body.Close() }()
-	return json.NewDecoder(r.Body).Decode(v)
-}

package/go/internal/server/server_bench_test.go

@@ -1,122 +0,0 @@
-package server
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func setupBenchServer(b *testing.B, lines int) (*Server, string) {
-	b.Helper()
-
-	// Generate markdown content
-	var sb strings.Builder
-	sb.WriteString("# Benchmark Document\n\n")
-	for i := range lines {
-		switch i % 10 {
-		case 0:
-			fmt.Fprintf(&sb, "## Section %d\n\n", i/10)
-		case 5:
-			sb.WriteString("```go\nfunc hello() {\n\tfmt.Println(\"world\")\n}\n```\n\n")
-		default:
-			fmt.Fprintf(&sb, "Paragraph %d with **bold** and *italic* text and `code`.\n\n", i)
-		}
-	}
-
-	// Write to temp file
-	tmpDir := b.TempDir()
-	filePath := filepath.Join(tmpDir, "bench.md")
-	if err := os.WriteFile(filePath, []byte(sb.String()), 0644); err != nil {
-		b.Fatal(err)
-	}
-
-	srv, err := NewServer(Options{
-		Files: []FileEntry{{FilePath: filePath}},
-		Port:  0,
-		Host:  "127.0.0.1",
-	})
-	if err != nil {
-		b.Fatal(err)
-	}
-
-	return srv, filePath
-}
-
-// BenchmarkSSRPage measures the full SSR page render (TTFB equivalent).
-func BenchmarkSSRPage1000Lines(b *testing.B) {
-	srv, _ := setupBenchServer(b, 1000)
-	defer srv.watcher.Close()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		req := httptest.NewRequest("GET", "/", nil)
-		w := httptest.NewRecorder()
-		srv.mux.ServeHTTP(w, req)
-		if w.Code != http.StatusOK {
-			b.Fatalf("unexpected status %d", w.Code)
-		}
-	}
-}
-
-func BenchmarkSSRPage3000Lines(b *testing.B) {
-	srv, _ := setupBenchServer(b, 3000)
-	defer srv.watcher.Close()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		req := httptest.NewRequest("GET", "/", nil)
-		w := httptest.NewRecorder()
-		srv.mux.ServeHTTP(w, req)
-		if w.Code != http.StatusOK {
-			b.Fatalf("unexpected status %d", w.Code)
-		}
-	}
-}
-
-// BenchmarkGetDocument measures the /api/document JSON response.
-func BenchmarkGetDocument1000Lines(b *testing.B) {
-	srv, filePath := setupBenchServer(b, 1000)
-	defer srv.watcher.Close()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		req := httptest.NewRequest("GET", "/api/document?path="+filePath, nil)
-		w := httptest.NewRecorder()
-		srv.mux.ServeHTTP(w, req)
-		if w.Code != http.StatusOK {
-			b.Fatalf("unexpected status %d", w.Code)
-		}
-	}
-}
-
-// BenchmarkStartup measures cold server creation (init + first render).
-func BenchmarkServerStartup1000Lines(b *testing.B) {
-	var sb strings.Builder
-	sb.WriteString("# Benchmark Document\n\n")
-	for i := range 1000 {
-		fmt.Fprintf(&sb, "Paragraph %d with **bold** text.\n\n", i)
-	}
-
-	tmpDir := b.TempDir()
-	filePath := filepath.Join(tmpDir, "bench.md")
-	if err := os.WriteFile(filePath, []byte(sb.String()), 0644); err != nil {
-		b.Fatal(err)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		srv, err := NewServer(Options{
-			Files: []FileEntry{{FilePath: filePath}},
-			Port:  0,
-			Host:  "127.0.0.1",
-		})
-		if err != nil {
-			b.Fatal(err)
-		}
-		srv.watcher.Close()
-	}
-}

package/go/internal/server/settings.go

@@ -1,110 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"net/http"
-	"os"
-	"path/filepath"
-)
-
-func DefaultSettings() Settings {
-	return Settings{
-		Version:    1,
-		FontFamily: FontSerif,
-	}
-}
-
-func settingsPath() string {
-	home, err := os.UserHomeDir()
-	if err != nil || home == "" {
-		return ".readit/settings.json"
-	}
-	return filepath.Join(home, ".readit", "settings.json")
-}
-
-func ReadSettings() (Settings, error) {
-	data, err := os.ReadFile(settingsPath())
-	if err != nil {
-		return DefaultSettings(), err
-	}
-	s := DefaultSettings()
-	if err := json.Unmarshal(data, &s); err != nil {
-		return DefaultSettings(), err
-	}
-	return s, nil
-}
-
-func WriteSettings(s Settings) error {
-	path := settingsPath()
-	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
-		return err
-	}
-	data, err := json.MarshalIndent(s, "", "  ")
-	if err != nil {
-		return err
-	}
-	tmp := path + ".tmp"
-	if err := os.WriteFile(tmp, data, 0644); err != nil {
-		return err
-	}
-	return os.Rename(tmp, path)
-}
-
-func (s *Server) getSettings(w http.ResponseWriter, r *http.Request) {
-	s.mu.RLock()
-	settings := s.settings
-	s.mu.RUnlock()
-	writeJSON(w, http.StatusOK, settings)
-}
-
-func (s *Server) updateSettings(w http.ResponseWriter, r *http.Request) {
-	var body struct {
-		FontFamily  string       `json:"fontFamily"`
-		Keybindings []Keybinding `json:"keybindings"`
-	}
-	if err := readJSON(r, &body); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid request body")
-		return
-	}
-
-	if body.FontFamily != "" {
-		if body.FontFamily != FontSerif && body.FontFamily != FontSansSerif {
-			writeError(w, http.StatusBadRequest, "fontFamily must be 'serif' or 'sans-serif'")
-			return
-		}
-	}
-
-	// Validate keybinding overrides
-	for _, kb := range body.Keybindings {
-		if kb.ID == "" {
-			writeError(w, http.StatusBadRequest, "keybinding id is required")
-			return
-		}
-		if kb.Binding != nil && kb.Binding.Key == "" {
-			writeError(w, http.StatusBadRequest, "keybinding key is required when binding is provided")
-			return
-		}
-	}
-
-	// Build new settings under write lock for atomicity
-	s.mu.Lock()
-	newSettings := s.settings
-
-	if body.FontFamily != "" {
-		newSettings.FontFamily = body.FontFamily
-	}
-	if body.Keybindings != nil {
-		newSettings.Keybindings = body.Keybindings
-	}
-
-	if err := WriteSettings(newSettings); err != nil {
-		s.mu.Unlock()
-		writeError(w, http.StatusInternalServerError, "failed to save settings")
-		return
-	}
-
-	s.settings = newSettings
-	s.mu.Unlock()
-
-	writeJSON(w, http.StatusOK, newSettings)
-}