@peaske7/readit 0.1.6 → 0.1.8

package/src/server/index.ts

@@ -19,6 +19,8 @@ import {
   type Comment,
   type DocumentSettings,
   type DocumentType,
+  type EditorScheme,
+  EditorSchemes,
   FontFamilies,
   type FontFamily,
 } from "../types/index.js";
@@ -30,7 +32,7 @@ function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
 }
 
 export interface FileEntry {
-  content: string;
+  content?: string;
   type: DocumentType;
   filePath: string;
 }
@@ -48,17 +50,43 @@ export interface ServerResult {
   server: { stop(): void };
 }
 
+interface ResolvedCommentsCacheEntry {
+  commentMtimeMs: number;
+  sourceHash: string;
+  comments: Comment[];
+}
+
+const resolvedCommentsCache = new Map<string, ResolvedCommentsCacheEntry>();
+
+function invalidateResolvedComments(filePath: string): void {
+  resolvedCommentsCache.delete(filePath);
+}
+
+async function canonicalPath(filePath: string): Promise<string> {
+  return fs.realpath(path.resolve(filePath));
+}
+
 async function readCommentsFromFile(
   filePath: string,
   sourceContent: string,
 ): Promise<Comment[]> {
   const commentPath = getCommentPath(filePath);
+  const sourceHash = computeHash(sourceContent);
 
   try {
+    const stats = await fs.stat(commentPath);
+    const cached = resolvedCommentsCache.get(filePath);
+    if (
+      cached &&
+      cached.sourceHash === sourceHash &&
+      cached.commentMtimeMs === stats.mtimeMs
+    ) {
+      return cached.comments;
+    }
+
     const content = await fs.readFile(commentPath, "utf-8");
     const file = parseCommentFile(content);
-
-    return file.comments.map((comment) => {
+    const resolvedComments = file.comments.map((comment) => {
       const textForMatching = comment.anchorPrefix || comment.selectedText;
       const anchor = findAnchorWithFallback({
         source: sourceContent,
@@ -81,8 +109,17 @@ async function readCommentsFromFile(
         anchorConfidence: AnchorConfidences.UNRESOLVED,
       };
     });
+
+    resolvedCommentsCache.set(filePath, {
+      sourceHash,
+      commentMtimeMs: stats.mtimeMs,
+      comments: resolvedComments,
+    });
+
+    return resolvedComments;
   } catch (err) {
     if (isErrnoException(err) && err.code === "ENOENT") {
+      invalidateResolvedComments(filePath);
       return [];
     }
     throw err;
@@ -110,6 +147,7 @@ async function writeCommentsToFile(
   const tempPath = `${commentPath}.tmp`;
   await fs.writeFile(tempPath, content, "utf-8");
   await fs.rename(tempPath, commentPath);
+  invalidateResolvedComments(filePath);
 }
 
 async function deleteCommentFile(filePath: string): Promise<void> {
@@ -121,30 +159,19 @@ async function deleteCommentFile(filePath: string): Promise<void> {
       throw err;
     }
   }
+  invalidateResolvedComments(filePath);
 }
 
-function getSettingsPath(sourcePath: string): string {
-  const absolute = path.resolve(sourcePath);
-  const normalized = absolute.replace(/^\//, "").replace(/^[A-Z]:[\\/]/, "");
-  return path.join(
-    os.homedir(),
-    ".readit",
-    "settings",
-    `${normalized}.settings.json`,
-  );
-}
+const SETTINGS_PATH = path.join(os.homedir(), ".readit", "settings.json");
 
 const DEFAULT_SETTINGS: DocumentSettings = {
   version: 1,
   fontFamily: FontFamilies.SERIF,
 };
 
-async function readSettingsFromFile(
-  filePath: string,
-): Promise<DocumentSettings> {
-  const settingsPath = getSettingsPath(filePath);
+async function readSettings(): Promise<DocumentSettings> {
   try {
-    const content = await fs.readFile(settingsPath, "utf-8");
+    const content = await fs.readFile(SETTINGS_PATH, "utf-8");
     return JSON.parse(content) as DocumentSettings;
   } catch (err) {
     if (isErrnoException(err) && err.code === "ENOENT") {
@@ -154,24 +181,23 @@ async function readSettingsFromFile(
   }
 }
 
-async function writeSettingsToFile(
-  filePath: string,
-  settings: DocumentSettings,
-): Promise<void> {
-  const settingsPath = getSettingsPath(filePath);
-  const settingsDir = dirname(settingsPath);
-
+async function writeSettings(settings: DocumentSettings): Promise<void> {
+  const settingsDir = dirname(SETTINGS_PATH);
   await fs.mkdir(settingsDir, { recursive: true });
 
-  const tempPath = `${settingsPath}.tmp`;
+  const tempPath = `${SETTINGS_PATH}.tmp`;
   await fs.writeFile(tempPath, JSON.stringify(settings, null, 2), "utf-8");
-  await fs.rename(tempPath, settingsPath);
+  await fs.rename(tempPath, SETTINGS_PATH);
 }
 
 function isValidFontFamily(value: unknown): value is FontFamily {
   return value === FontFamilies.SERIF || value === FontFamilies.SANS_SERIF;
 }
 
+function isValidEditorScheme(value: unknown): value is EditorScheme {
+  return Object.values(EditorSchemes).includes(value as EditorScheme);
+}
+
 // ─── PID file helpers ───────────────────────────────────────────────
 
 export const SERVER_INFO_PATH = path.join(
@@ -213,17 +239,15 @@ function errorResponse(message: string, status: number): Response {
 
 interface RouteContext {
   filePath: string;
-  getCurrentContent: () => string;
+  getCurrentContent: () => Promise<string>;
 }
 
 // ─── Route handlers ─────────────────────────────────────────────────
 
 async function getComments(ctx: RouteContext): Promise<Response> {
   try {
-    const comments = await readCommentsFromFile(
-      ctx.filePath,
-      ctx.getCurrentContent(),
-    );
+    const currentContent = await ctx.getCurrentContent();
+    const comments = await readCommentsFromFile(ctx.filePath, currentContent);
     return json({ comments });
   } catch (err) {
     console.error("Failed to read comments:", err);
@@ -249,7 +273,7 @@ async function addComment(ctx: RouteContext, req: Request): Promise<Response> {
       return errorResponse("Missing required fields", 400);
     }
 
-    const currentContent = ctx.getCurrentContent();
+    const currentContent = await ctx.getCurrentContent();
     const newComment = createComment(
       selectedText,
       commentText,
@@ -285,7 +309,7 @@ async function updateComment(
       return errorResponse("Missing comment text", 400);
     }
 
-    const currentContent = ctx.getCurrentContent();
+    const currentContent = await ctx.getCurrentContent();
     const existingComments = await readCommentsFromFile(
       ctx.filePath,
       currentContent,
@@ -311,7 +335,7 @@ async function updateComment(
 
 async function deleteComment(ctx: RouteContext, id: string): Promise<Response> {
   try {
-    const currentContent = ctx.getCurrentContent();
+    const currentContent = await ctx.getCurrentContent();
     const existingComments = await readCommentsFromFile(
       ctx.filePath,
       currentContent,
@@ -371,7 +395,7 @@ async function reanchorComment(
       return errorResponse("Missing required fields", 400);
     }
 
-    const currentContent = ctx.getCurrentContent();
+    const currentContent = await ctx.getCurrentContent();
     const existingComments = await readCommentsFromFile(
       ctx.filePath,
       currentContent,
@@ -409,9 +433,9 @@ async function reanchorComment(
   }
 }
 
-async function getSettings(ctx: RouteContext): Promise<Response> {
+async function getSettingsRoute(): Promise<Response> {
   try {
-    const settings = await readSettingsFromFile(ctx.filePath);
+    const settings = await readSettings();
     return json(settings);
   } catch (err) {
     console.error("Failed to read settings:", err);
@@ -419,27 +443,28 @@ async function getSettings(ctx: RouteContext): Promise<Response> {
   }
 }
 
-async function updateSettings(
-  ctx: RouteContext,
-  req: Request,
-): Promise<Response> {
+async function updateSettingsRoute(req: Request): Promise<Response> {
   try {
     const body = await req.json();
-    const { fontFamily, keybindings } = body;
+    const { fontFamily, editorScheme, keybindings } = body;
 
     if (fontFamily !== undefined && !isValidFontFamily(fontFamily)) {
       return errorResponse("Invalid font family", 400);
     }
 
-    // Read current settings and merge
-    const current = await readSettingsFromFile(ctx.filePath);
+    if (editorScheme !== undefined && !isValidEditorScheme(editorScheme)) {
+      return errorResponse("Invalid editor scheme", 400);
+    }
+
+    const current = await readSettings();
     const settings: DocumentSettings = {
       ...current,
       ...(fontFamily !== undefined && { fontFamily }),
+      ...(editorScheme !== undefined && { editorScheme }),
       ...(keybindings !== undefined && { keybindings }),
     };
 
-    await writeSettingsToFile(ctx.filePath, settings);
+    await writeSettings(settings);
     return json(settings);
   } catch (err) {
     console.error("Failed to save settings:", err);
@@ -452,13 +477,26 @@ async function updateSettings(
 function createDocumentStream(
   sseClients: Set<ReadableStreamDefaultController>,
 ): Response {
+  let pingInterval: ReturnType<typeof setInterval>;
+  let captured: ReadableStreamDefaultController;
+
   const stream = new ReadableStream({
     start(controller) {
+      captured = controller;
       controller.enqueue("data: connected\n\n");
       sseClients.add(controller);
+      pingInterval = setInterval(() => {
+        try {
+          controller.enqueue("data: ping\n\n");
+        } catch {
+          clearInterval(pingInterval);
+          sseClients.delete(controller);
+        }
+      }, 5000);
     },
-    cancel(controller) {
-      sseClients.delete(controller);
+    cancel() {
+      clearInterval(pingInterval);
+      sseClients.delete(captured);
     },
   });
 
@@ -471,27 +509,30 @@ function createDocumentStream(
   });
 }
 
-function createHeartbeat(isDev: boolean): Response {
+function createHeartbeat(
+  onOpen: (controller: ReadableStreamDefaultController) => void,
+  onClose: (controller: ReadableStreamDefaultController) => void,
+): Response {
   let interval: ReturnType<typeof setInterval>;
+  let captured: ReadableStreamDefaultController;
 
   const stream = new ReadableStream({
     start(controller) {
+      captured = controller;
       controller.enqueue("data: connected\n\n");
+      onOpen(controller);
       interval = setInterval(() => {
         try {
           controller.enqueue("data: ping\n\n");
         } catch {
           clearInterval(interval);
+          onClose(controller);
         }
       }, 5000);
     },
     cancel() {
       clearInterval(interval);
-      if (isDev) return;
-      setTimeout(() => {
-        console.log("\nBrowser disconnected, shutting down...");
-        process.exit(0);
-      }, 100);
+      onClose(captured);
     },
   });
 
@@ -536,7 +577,8 @@ function extractCommentId(pathname: string): string | undefined {
 // ─── Multi-file state ───────────────────────────────────────────────
 
 interface FileState {
-  content: string;
+  content: string | null;
+  isLoaded: boolean;
   type: DocumentType;
   debounceTimer: ReturnType<typeof setTimeout> | null;
 }
@@ -556,7 +598,8 @@ function createServer(options: ServerOptions): ServerWithWatchers {
 
   for (const entry of options.files) {
     fileMap.set(entry.filePath, {
-      content: entry.content,
+      content: entry.content ?? null,
+      isLoaded: entry.content !== undefined,
       type: entry.type,
       debounceTimer: null,
     });
@@ -565,6 +608,60 @@ function createServer(options: ServerOptions): ServerWithWatchers {
 
   const defaultPath = fileOrder[0];
   const sseClients = new Set<ReadableStreamDefaultController>();
+  const heartbeatClients = new Set<ReadableStreamDefaultController>();
+  let shutdownTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function sendEvent(event: unknown): void {
+    const message = `data: ${JSON.stringify(event)}\n\n`;
+    for (const controller of sseClients) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        sseClients.delete(controller);
+      }
+    }
+  }
+
+  function clearShutdownTimer(): void {
+    if (!shutdownTimer) return;
+    clearTimeout(shutdownTimer);
+    shutdownTimer = null;
+  }
+
+  function onHeartbeatOpen(controller: ReadableStreamDefaultController): void {
+    heartbeatClients.add(controller);
+    clearShutdownTimer();
+  }
+
+  function onHeartbeatClose(controller: ReadableStreamDefaultController): void {
+    heartbeatClients.delete(controller);
+    if (isDev || heartbeatClients.size > 0 || shutdownTimer) return;
+
+    shutdownTimer = setTimeout(() => {
+      if (heartbeatClients.size > 0) {
+        clearShutdownTimer();
+        return;
+      }
+      console.log("\nBrowser disconnected, shutting down...");
+      process.exit(0);
+    }, 1500);
+  }
+
+  async function ensureFileContent(filePath: string): Promise<string> {
+    const state = fileMap.get(filePath);
+    if (!state) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    if (state.isLoaded && state.content !== null) {
+      return state.content;
+    }
+
+    const content = await fs.readFile(filePath, "utf-8");
+    state.content = content;
+    state.isLoaded = true;
+    return content;
+  }
 
   // Resolve the target file from ?path= query param, falling back to first file
   function resolveContext(url: URL): RouteContext | null {
@@ -573,7 +670,7 @@ function createServer(options: ServerOptions): ServerWithWatchers {
     if (!state) return null;
     return {
       filePath: requestedPath,
-      getCurrentContent: () => state.content,
+      getCurrentContent: () => ensureFileContent(requestedPath),
     };
   }
 
@@ -600,18 +697,12 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         state.debounceTimer = setTimeout(async () => {
           try {
             const newContent = await fs.readFile(targetPath, "utf-8");
-            if (newContent !== state.content) {
+            if (!state.isLoaded || newContent !== state.content) {
               state.content = newContent;
+              state.isLoaded = true;
+              invalidateResolvedComments(targetPath);
               console.log(`File changed: ${basename(targetPath)}`);
-
-              const message = `data: ${JSON.stringify({ type: "update", path: targetPath })}\n\n`;
-              for (const controller of sseClients) {
-                try {
-                  controller.enqueue(message);
-                } catch {
-                  sseClients.delete(controller);
-                }
-              }
+              sendEvent({ type: "document-updated", path: targetPath });
             }
           } catch (err) {
             console.error(`Failed to read updated file ${targetPath}:`, err);
@@ -628,6 +719,7 @@ function createServer(options: ServerOptions): ServerWithWatchers {
   const server = Bun.serve({
     port: options.port,
     hostname: options.host,
+    idleTimeout: 255, // max value (seconds) — SSE streams stay open long
 
     async fetch(req) {
       const url = new URL(req.url);
@@ -646,11 +738,15 @@ function createServer(options: ServerOptions): ServerWithWatchers {
             type: state.type,
           };
         });
-        return json({ files, clean: options.clean || false });
+        return json({
+          files,
+          clean: options.clean || false,
+          workingDirectory: process.cwd(),
+        });
       }
 
-      // Hot-add or refresh a file
-      if (pathname === "/api/files" && method === "POST") {
+      // Register a document for this session without forcing focus
+      if (pathname === "/api/documents" && method === "POST") {
         try {
           const { path: requestedPath } = await req.json();
 
@@ -658,7 +754,15 @@ function createServer(options: ServerOptions): ServerWithWatchers {
             return errorResponse("Missing 'path' field", 400);
           }
 
-          const filePath = path.resolve(requestedPath);
+          let filePath: string;
+          try {
+            filePath = await canonicalPath(requestedPath);
+          } catch (err) {
+            if (isErrnoException(err) && err.code === "ENOENT") {
+              return errorResponse(`File not found: ${requestedPath}`, 404);
+            }
+            throw err;
+          }
           const fileType = getFileType(filePath);
 
           if (!fileType) {
@@ -668,65 +772,45 @@ function createServer(options: ServerOptions): ServerWithWatchers {
             );
           }
 
-          let content: string;
-          try {
-            content = await fs.readFile(filePath, "utf-8");
-          } catch (err) {
-            if (isErrnoException(err) && err.code === "ENOENT") {
-              return errorResponse(`File not found: ${filePath}`, 404);
-            }
-            throw err;
-          }
-
           const existingState = fileMap.get(filePath);
 
           if (existingState) {
-            // File already loaded — refresh content
-            existingState.content = content;
-            const message = `data: ${JSON.stringify({ type: "update", path: filePath })}\n\n`;
-            for (const controller of sseClients) {
-              try {
-                controller.enqueue(message);
-              } catch {
-                sseClients.delete(controller);
-              }
-            }
+            return json({
+              path: filePath,
+              fileName: basename(filePath),
+              type: fileType,
+              status: "present",
+            });
           } else {
-            // New file — add to server
+            // New document — register metadata only, load content on demand
             fileMap.set(filePath, {
-              content,
+              content: null,
+              isLoaded: false,
               type: fileType,
               debounceTimer: null,
             });
             fileOrder.push(filePath);
 
-            // Set up file watcher for the new file
             const watcher = watchFile(filePath);
             if (watcher) watchers.push(watcher);
 
-            const message = `data: ${JSON.stringify({
-              type: "file-added",
+            sendEvent({
+              type: "document-added",
               path: filePath,
               fileName: basename(filePath),
               fileType,
-            })}\n\n`;
-            for (const controller of sseClients) {
-              try {
-                controller.enqueue(message);
-              } catch {
-                sseClients.delete(controller);
-              }
-            }
+            });
           }
 
           return json({
             path: filePath,
             fileName: basename(filePath),
             type: fileType,
+            status: "added",
           });
         } catch (err) {
-          console.error("Failed to add file:", err);
-          return errorResponse("Failed to add file", 500);
+          console.error("Failed to add document:", err);
+          return errorResponse("Failed to add document", 500);
         }
       }
 
@@ -735,8 +819,9 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         const ctxOrRes = requireContext(url);
         if (ctxOrRes instanceof Response) return ctxOrRes;
         const state = fileMap.get(ctxOrRes.filePath)!;
+        const content = await ctxOrRes.getCurrentContent();
         return json({
-          content: state.content,
+          content,
           type: state.type,
           filePath: ctxOrRes.filePath,
           fileName: basename(ctxOrRes.filePath),
@@ -753,7 +838,7 @@ function createServer(options: ServerOptions): ServerWithWatchers {
       }
 
       if (pathname === "/api/heartbeat" && method === "GET") {
-        return createHeartbeat(isDev);
+        return createHeartbeat(onHeartbeatOpen, onHeartbeatClose);
       }
 
       // Comments routes
@@ -798,30 +883,18 @@ function createServer(options: ServerOptions): ServerWithWatchers {
         }
       }
 
-      // Settings routes
+      // Settings routes (global, not per-document)
       if (pathname === "/api/settings" && method === "GET") {
-        const ctxOrRes = requireContext(url);
-        if (ctxOrRes instanceof Response) return ctxOrRes;
-        return getSettings(ctxOrRes);
+        return getSettingsRoute();
       }
 
       if (pathname === "/api/settings" && method === "PUT") {
-        const ctxOrRes = requireContext(url);
-        if (ctxOrRes instanceof Response) return ctxOrRes;
-        return updateSettings(ctxOrRes, req);
+        return updateSettingsRoute(req);
       }
 
       // ── Static / SPA serving ────────────────────────────────
 
-      if (isDev && pathname === "/") {
-        return Response.redirect("http://localhost:5173", 302);
-      }
-
-      if (!isDev) {
-        return serveStaticFile(distPath, pathname);
-      }
-
-      return new Response("Not Found", { status: 404 });
+      return serveStaticFile(distPath, pathname);
     },
   });
 

package/src/store/index.test.ts

@@ -64,6 +64,28 @@ describe("AppStore", () => {
         "/test/file.html",
       ]);
     });
+
+    it("adds document without activating when active is false", () => {
+      store.getState().openDocument(mockDoc);
+      store.getState().openDocument(mockDoc2, { active: false });
+      expect(store.getState().activeDocumentPath).toBe("/test/file.md");
+      expect(store.getState().documentOrder).toEqual([
+        "/test/file.md",
+        "/test/file.html",
+      ]);
+    });
+
+    it("updates existing document without stealing focus when active is false", () => {
+      store.getState().openDocument(mockDoc);
+      store.getState().openDocument(mockDoc2);
+      store
+        .getState()
+        .openDocument({ ...mockDoc, content: "# Updated" }, { active: false });
+      expect(store.getState().activeDocumentPath).toBe("/test/file.html");
+      expect(
+        store.getState().documents.get("/test/file.md")!.document.content,
+      ).toBe("# Updated");
+    });
   });
 
   describe("closeDocument", () => {

package/src/store/index.ts

@@ -23,9 +23,11 @@ export interface AppStore {
   documents: Map<string, DocumentState>;
   activeDocumentPath: string | null;
   documentOrder: string[];
+  workingDirectory: string | null;
 
   // Global actions
-  openDocument: (doc: Document) => void;
+  setWorkingDirectory: (dir: string) => void;
+  openDocument: (doc: Document, opts?: { active?: boolean }) => void;
   closeDocument: (filePath: string) => void;
   setActiveDocument: (filePath: string) => void;
 
@@ -103,17 +105,35 @@ export function createAppStore() {
       documents: new Map(),
       activeDocumentPath: null,
       documentOrder: [],
+      workingDirectory: null,
 
-      openDocument: (doc) => {
+      setWorkingDirectory: (dir) => set({ workingDirectory: dir }),
+
+      openDocument: (doc, opts) => {
         set((prev) => {
+          const active = opts?.active ?? true;
+          const nextActive =
+            active || !prev.activeDocumentPath
+              ? doc.filePath
+              : prev.activeDocumentPath;
+
           if (prev.documents.has(doc.filePath)) {
-            return { activeDocumentPath: doc.filePath };
+            const newDocs = new Map(prev.documents);
+            const prevDoc = newDocs.get(doc.filePath)!;
+            newDocs.set(doc.filePath, {
+              ...prevDoc,
+              document: { ...prevDoc.document, ...doc },
+            });
+            return {
+              documents: newDocs,
+              activeDocumentPath: nextActive,
+            };
           }
           const newDocs = new Map(prev.documents);
           newDocs.set(doc.filePath, createInitialDocumentState(doc));
           return {
             documents: newDocs,
-            activeDocumentPath: doc.filePath,
+            activeDocumentPath: nextActive,
             documentOrder: [...prev.documentOrder, doc.filePath],
           };
         });