@peaske7/readit 0.1.5 → 0.1.7

package/src/server/index.ts

@@ -13,11 +13,14 @@ import {
   serializeComments,
   truncateSelection,
 } from "../lib/comment-storage.js";
+import { getFileType } from "../lib/utils.js";
 import {
   AnchorConfidences,
   type Comment,
   type DocumentSettings,
   type DocumentType,
+  type EditorScheme,
+  EditorSchemes,
   FontFamilies,
   type FontFamily,
 } from "../types/index.js";
@@ -29,7 +32,7 @@ function isErrnoException(err: unknown): err is NodeJS.ErrnoException {
 }
 
 export interface FileEntry {
-  content: string;
+  content?: string;
   type: DocumentType;
   filePath: string;
 }
@@ -47,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,
@@ -80,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;
@@ -109,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> {
@@ -120,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") {
@@ -153,24 +181,50 @@ 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(
+  os.homedir(),
+  ".readit",
+  "server.json",
+);
+
+async function writeServerInfo(port: number): Promise<void> {
+  await fs.mkdir(path.dirname(SERVER_INFO_PATH), { recursive: true });
+  await fs.writeFile(
+    SERVER_INFO_PATH,
+    JSON.stringify({ port, pid: process.pid }),
+    "utf-8",
+  );
+}
+
+export async function removeServerInfo(): Promise<void> {
+  try {
+    await fs.unlink(SERVER_INFO_PATH);
+  } catch (err) {
+    if (!isErrnoException(err) || err.code !== "ENOENT") {
+      console.error("Failed to remove server info:", err);
+    }
+  }
+}
+
 // ─── Response helpers ───────────────────────────────────────────────
 
 function json(data: unknown, status = 200): Response {
@@ -185,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);
@@ -221,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,
@@ -257,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,
@@ -283,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,
@@ -343,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,
@@ -381,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);
@@ -391,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);
@@ -424,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);
     },
   });
 
@@ -508,7 +574,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;
 }
@@ -528,7 +595,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,
     });
@@ -538,6 +606,33 @@ function createServer(options: ServerOptions): ServerWithWatchers {
   const defaultPath = fileOrder[0];
   const sseClients = new Set<ReadableStreamDefaultController>();
 
+  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);
+      }
+    }
+  }
+
+  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 {
     const requestedPath = url.searchParams.get("path") ?? defaultPath;
@@ -545,7 +640,7 @@ function createServer(options: ServerOptions): ServerWithWatchers {
     if (!state) return null;
     return {
       filePath: requestedPath,
-      getCurrentContent: () => state.content,
+      getCurrentContent: () => ensureFileContent(requestedPath),
     };
   }
 
@@ -560,9 +655,41 @@ function createServer(options: ServerOptions): ServerWithWatchers {
   const isDev = process.env.NODE_ENV === "development";
   const distPath = import.meta.dir;
 
+  function watchFile(targetPath: string): FSWatcher | null {
+    try {
+      const watcher = watch(targetPath, async (eventType) => {
+        if (eventType !== "change") return;
+
+        const state = fileMap.get(targetPath);
+        if (!state) return;
+
+        if (state.debounceTimer) clearTimeout(state.debounceTimer);
+        state.debounceTimer = setTimeout(async () => {
+          try {
+            const newContent = await fs.readFile(targetPath, "utf-8");
+            if (!state.isLoaded || newContent !== state.content) {
+              state.content = newContent;
+              state.isLoaded = true;
+              invalidateResolvedComments(targetPath);
+              console.log(`File changed: ${basename(targetPath)}`);
+              sendEvent({ type: "document-updated", path: targetPath });
+            }
+          } catch (err) {
+            console.error(`Failed to read updated file ${targetPath}:`, err);
+          }
+        }, 100);
+      });
+      return watcher;
+    } catch (err) {
+      console.warn(`File watching not available for ${targetPath}:`, err);
+      return null;
+    }
+  }
+
   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);
@@ -581,7 +708,80 @@ 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(),
+        });
+      }
+
+      // Register a document for this session without forcing focus
+      if (pathname === "/api/documents" && method === "POST") {
+        try {
+          const { path: requestedPath } = await req.json();
+
+          if (!requestedPath || typeof requestedPath !== "string") {
+            return errorResponse("Missing 'path' field", 400);
+          }
+
+          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) {
+            return errorResponse(
+              `Unsupported file type: ${filePath} (expected .md, .markdown, .html, or .htm)`,
+              400,
+            );
+          }
+
+          const existingState = fileMap.get(filePath);
+
+          if (existingState) {
+            return json({
+              path: filePath,
+              fileName: basename(filePath),
+              type: fileType,
+              status: "present",
+            });
+          } else {
+            // New document — register metadata only, load content on demand
+            fileMap.set(filePath, {
+              content: null,
+              isLoaded: false,
+              type: fileType,
+              debounceTimer: null,
+            });
+            fileOrder.push(filePath);
+
+            const watcher = watchFile(filePath);
+            if (watcher) watchers.push(watcher);
+
+            sendEvent({
+              type: "document-added",
+              path: filePath,
+              fileName: basename(filePath),
+              fileType,
+            });
+          }
+
+          return json({
+            path: filePath,
+            fileName: basename(filePath),
+            type: fileType,
+            status: "added",
+          });
+        } catch (err) {
+          console.error("Failed to add document:", err);
+          return errorResponse("Failed to add document", 500);
+        }
       }
 
       // Single document (backward compat + path-aware)
@@ -589,8 +789,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),
@@ -652,70 +853,27 @@ 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);
     },
   });
 
   // Set up per-file watchers after Bun.serve() succeeds to avoid
   // leaking FSWatcher handles if the server fails to bind.
   const watchers: FSWatcher[] = [];
-  for (const filePath of fileOrder) {
-    try {
-      const watcher = watch(filePath, async (eventType) => {
-        if (eventType !== "change") return;
-
-        const state = fileMap.get(filePath);
-        if (!state) return;
-
-        if (state.debounceTimer) clearTimeout(state.debounceTimer);
-        state.debounceTimer = setTimeout(async () => {
-          try {
-            const newContent = await fs.readFile(filePath, "utf-8");
-            if (newContent !== state.content) {
-              state.content = newContent;
-              console.log(`File changed: ${basename(filePath)}`);
-
-              const message = `data: ${JSON.stringify({ type: "update", path: filePath })}\n\n`;
-              for (const controller of sseClients) {
-                try {
-                  controller.enqueue(message);
-                } catch {
-                  sseClients.delete(controller);
-                }
-              }
-            }
-          } catch (err) {
-            console.error(`Failed to read updated file ${filePath}:`, err);
-          }
-        }, 100);
-      });
-      watchers.push(watcher);
-    } catch (err) {
-      console.warn(`File watching not available for ${filePath}:`, err);
-    }
+  for (const fp of fileOrder) {
+    const watcher = watchFile(fp);
+    if (watcher) watchers.push(watcher);
   }
 
   return { server, watchers };
@@ -745,6 +903,8 @@ export async function startServer(
 
       const actualPort = server.port ?? port;
 
+      await writeServerInfo(actualPort);
+
       return {
         port: actualPort,
         url: `http://${displayHost}:${actualPort}`,

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],
           };
         });