@ripla/godd-mcp 1.0.4-canary.8 → 1.0.4

package/{notes-app → notes/app}/src/hooks/useEditSession.test.ts

@@ -43,6 +43,15 @@ function mockResponse(body: unknown, status = 200): Response {
 }
 
 const apiFetchMock = vi.fn<(path: string, init?: RequestInit) => Promise<Response>>();
+const triggerPeriodicSync = vi.hoisted(() => vi.fn());
+
+vi.mock("@/hooks/usePeriodicSync", () => ({
+  usePeriodicSync: ({ onSync, enabled }: { onSync: () => void | Promise<void>; enabled: boolean }) => {
+    triggerPeriodicSync.mockImplementation(() => {
+      if (enabled) void onSync();
+    });
+  },
+}));
 
 vi.mock("@/lib/api", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@/lib/api")>();
@@ -138,6 +147,31 @@ describe("useEditSession", () => {
       expect(result.current.error).toBeNull();
     });
 
+    it("保存後の fetchSession で prNumber / prUrl が更新される", async () => {
+      const saveResult = { branch: "edit/user", sha: "abc123", commitCount: 4 };
+      const updatedSession = {
+        ...MOCK_SESSION,
+        prNumber: 99,
+        prUrl: "https://github.com/org/repo/pull/99",
+      };
+      apiFetchMock
+        .mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }))
+        .mockResolvedValueOnce(mockResponse(saveResult))
+        .mockResolvedValueOnce(mockResponse({ session: updatedSession }));
+
+      const { result } = renderHook(() => useEditSession());
+      await waitFor(() => expect(result.current.session?.prNumber).toBe(42));
+
+      await act(async () => {
+        await result.current.saveFile("docs/README.md", "new content", "sha123");
+      });
+
+      await waitFor(() => {
+        expect(result.current.session?.prNumber).toBe(99);
+        expect(result.current.session?.prUrl).toBe(updatedSession.prUrl);
+      });
+    });
+
     it("sha が null の場合 body に sha を含めない", async () => {
       const saveResult = { branch: "edit/user", sha: "abc123", commitCount: 1 };
       apiFetchMock
@@ -231,40 +265,154 @@ describe("useEditSession", () => {
     });
   });
 
-  describe("discardChanges", () => {
-    it("破棄成功時に session を null にし true を返す", async () => {
+  describe("periodic sync", () => {
+    it("背景 poll で prGithub.state が更新される", async () => {
+      apiFetchMock.mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }));
+
+      const { result } = renderHook(() => useEditSession({ syncEnabled: true }));
+      await waitFor(() => expect(result.current.session?.prGithub?.state).toBe("open"));
+
+      const mergedSession: EditSession = {
+        ...MOCK_SESSION,
+        prGithub: {
+          ...MOCK_SESSION.prGithub!,
+          state: "closed",
+          merged: true,
+        },
+      };
+      apiFetchMock.mockResolvedValueOnce(mockResponse({ session: mergedSession }));
+
+      await act(async () => {
+        triggerPeriodicSync();
+      });
+
+      await waitFor(() => {
+        expect(result.current.session?.prGithub?.state).toBe("closed");
+        expect(result.current.session?.prGithub?.merged).toBe(true);
+      });
+    });
+
+    it("背景 poll で 404 のとき session を維持する", async () => {
+      apiFetchMock.mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }));
+
+      const { result } = renderHook(() => useEditSession({ syncEnabled: true }));
+      await waitFor(() => expect(result.current.session).toEqual(MOCK_SESSION));
+
+      apiFetchMock.mockResolvedValueOnce(mockResponse(null, 404));
+
+      await act(async () => {
+        triggerPeriodicSync();
+      });
+
+      expect(result.current.session).toEqual(MOCK_SESSION);
+    });
+
+    it("背景 poll 失敗時は session を維持する", async () => {
+      apiFetchMock.mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }));
+
+      const { result } = renderHook(() => useEditSession({ syncEnabled: true }));
+      await waitFor(() => expect(result.current.session).toEqual(MOCK_SESSION));
+
+      apiFetchMock.mockRejectedValueOnce(new Error("Network error"));
+
+      await act(async () => {
+        triggerPeriodicSync();
+      });
+
+      expect(result.current.session).toEqual(MOCK_SESSION);
+    });
+
+    it("mutation 直後の foreground 再取得中に到着した古い background poll 応答が新しい session を上書きしない（#935）", async () => {
+      const FRESH: EditSession = { ...MOCK_SESSION, commitCount: 4, prNumber: 99 };
+      const saveResult = { branch: "edit/user", sha: "abc123", commitCount: 4 };
+
+      let resolveStalePoll: ((r: Response) => void) | undefined;
+      const stalePoll = new Promise<Response>((resolve) => {
+        resolveStalePoll = resolve;
+      });
+
       apiFetchMock
-        .mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }))
-        .mockResolvedValueOnce(mockResponse({ success: true }))
-        .mockResolvedValueOnce(mockResponse({ session: null }));
+        .mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION })) // 1: mount foreground
+        .mockReturnValueOnce(stalePoll) // 2: background poll（in-flight・古い応答は後で返す）
+        .mockResolvedValueOnce(mockResponse(saveResult)) // 3: PUT save
+        .mockResolvedValueOnce(mockResponse({ session: FRESH })); // 4: 保存後の foreground 再取得
 
-      const { result } = renderHook(() => useEditSession());
-      await waitFor(() => expect(result.current.session).toBeTruthy());
+      const { result } = renderHook(() => useEditSession({ syncEnabled: true }));
+      await waitFor(() => expect(result.current.session?.commitCount).toBe(3));
 
-      let ok: unknown;
+      // background poll を in-flight にする（beginPollRequest で poll seq が進む）
       await act(async () => {
-        ok = await result.current.discardChanges();
+        triggerPeriodicSync();
+        await Promise.resolve();
       });
 
-      expect(ok).toBe(true);
-      expect(result.current.session).toBeNull();
+      // mutation（保存）→ foreground 再取得が新しい session を適用（beginLoadRequest が in-flight poll を無効化）
+      await act(async () => {
+        await result.current.saveFile("docs/README.md", "new", "sha123");
+      });
+      await waitFor(() => expect(result.current.session?.commitCount).toBe(4));
+      expect(result.current.session?.prNumber).toBe(99);
+
+      // 後着の古い background poll 応答が到着しても、新しい session を上書きしない
+      await act(async () => {
+        resolveStalePoll?.(mockResponse({ session: MOCK_SESSION }));
+        await Promise.resolve();
+      });
+
+      expect(result.current.session?.commitCount).toBe(4);
+      expect(result.current.session?.prNumber).toBe(99);
     });
 
-    it("破棄失敗時に error を設定し false を返す", async () => {
+    it("mutation 開始時に in-flight の background poll を無効化し、PUT 実行中に到着した古い応答を適用しない（#935）", async () => {
+      const STALE = { ...MOCK_SESSION, prNumber: 7 };
+      const FRESH = { ...MOCK_SESSION, prNumber: 99, commitCount: 4 };
+      const saveResult = { branch: "edit/user", sha: "abc123", commitCount: 4 };
+
+      let resolveStalePoll: ((r: Response) => void) | undefined;
+      const stalePoll = new Promise<Response>((resolve) => {
+        resolveStalePoll = resolve;
+      });
+      let resolvePut: ((r: Response) => void) | undefined;
+      const putPromise = new Promise<Response>((resolve) => {
+        resolvePut = resolve;
+      });
+
       apiFetchMock
-        .mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }))
-        .mockResolvedValueOnce(mockResponse({ detail: "Server error" }, 500));
+        .mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION })) // 1: mount foreground
+        .mockReturnValueOnce(stalePoll) // 2: background poll（in-flight）
+        .mockReturnValueOnce(putPromise) // 3: PUT save（in-flight に保持）
+        .mockResolvedValueOnce(mockResponse({ session: FRESH })); // 4: 保存後の foreground 再取得
 
-      const { result } = renderHook(() => useEditSession());
-      await waitFor(() => expect(result.current.session).toBeTruthy());
+      const { result } = renderHook(() => useEditSession({ syncEnabled: true }));
+      await waitFor(() => expect(result.current.session?.prNumber).toBe(42));
 
-      let ok: unknown;
+      // background poll を in-flight にする
       await act(async () => {
-        ok = await result.current.discardChanges();
+        triggerPeriodicSync();
+        await Promise.resolve();
       });
 
-      expect(ok).toBe(false);
-      expect(result.current.error).toBe("Server error");
+      // saveFile を開始（PUT は in-flight のまま保持）。開始時の beginPollRequest が in-flight poll を無効化する
+      let savePromise: Promise<unknown> | undefined;
+      await act(async () => {
+        savePromise = result.current.saveFile("docs/README.md", "new", "sha123");
+        await Promise.resolve();
+      });
+
+      // PUT 実行中に古い background poll が解決しても、無効化済みのため適用されない
+      await act(async () => {
+        resolveStalePoll?.(mockResponse({ session: STALE }));
+        await Promise.resolve();
+      });
+      expect(result.current.session?.prNumber).toBe(42); // STALE(7) で上書きされない
+
+      // PUT 完了 → 保存後 foreground 取得が新しい session を適用
+      await act(async () => {
+        resolvePut?.(mockResponse(saveResult));
+        await savePromise;
+      });
+      expect(result.current.session?.prNumber).toBe(99);
+      expect(result.current.session?.commitCount).toBe(4);
     });
   });
 
@@ -272,15 +420,15 @@ describe("useEditSession", () => {
     it("error を null にリセットする", async () => {
       apiFetchMock
         .mockResolvedValueOnce(mockResponse({ session: MOCK_SESSION }))
-        .mockResolvedValueOnce(mockResponse({ detail: "fail" }, 500));
+        .mockResolvedValueOnce(mockResponse({ detail: "No changes" }, 400));
 
       const { result } = renderHook(() => useEditSession());
       await waitFor(() => expect(result.current.session).toBeTruthy());
 
       await act(async () => {
-        await result.current.discardChanges();
+        await result.current.createPr();
       });
-      expect(result.current.error).toBeTruthy();
+      expect(result.current.error).toBe("No changes");
 
       act(() => {
         result.current.clearError();

package/{notes-app → notes/app}/src/hooks/useEditSession.ts

@@ -1,5 +1,7 @@
 import { useState, useCallback, useEffect, useRef } from "react";
 import { apiFetch, encodePath, getErrorMessage } from "@/lib/api";
+import { usePeriodicSync } from "@/hooks/usePeriodicSync";
+import { GITHUB_SYNC_POLL_INTERVAL_MS } from "@/lib/github-sync";
 
 /** `/pr/my-session` が GitHub から付与する PR のライブ状態（DB の prNumber/prUrl は保持） */
 export type SessionPrGithub = {
@@ -33,43 +35,75 @@ type SaveResult = {
   prWarning?: string;
 };
 
-export function useEditSession() {
+export function useEditSession(options?: { syncEnabled?: boolean }) {
+  const syncEnabled = options?.syncEnabled ?? false;
   const [session, setSession] = useState<EditSession | null>(null);
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const mountedRef = useRef(true);
+  // foreground（初回・mutation 後の再取得）と background poll で seq を分離し、並走時に
+  // 先着の古い応答が後着の新しい session を上書きしないようにする（#935、#934 と同型）
+  const loadRequestSeq = useRef(0);
+  const pollRequestSeq = useRef(0);
 
   useEffect(() => {
     mountedRef.current = true;
     return () => { mountedRef.current = false; };
   }, []);
 
-  const fetchSession = useCallback(async () => {
+  // foreground 取得開始時は poll seq も進め、in-flight の background poll を無効化する
+  const beginLoadRequest = useCallback(() => {
+    loadRequestSeq.current += 1;
+    pollRequestSeq.current += 1;
+    return loadRequestSeq.current;
+  }, []);
+
+  // background poll は poll seq のみ進め、in-flight の foreground 取得は無効化しない
+  const beginPollRequest = useCallback(() => {
+    pollRequestSeq.current += 1;
+    return pollRequestSeq.current;
+  }, []);
+
+  const fetchSession = useCallback(async (options?: { background?: boolean }) => {
+    const background = options?.background ?? false;
+    const requestId = background ? beginPollRequest() : beginLoadRequest();
+    const isStale = () =>
+      background
+        ? requestId !== pollRequestSeq.current
+        : requestId !== loadRequestSeq.current;
     try {
       const res = await apiFetch("/pr/my-session");
-      if (!mountedRef.current) return;
+      if (!mountedRef.current || isStale()) return;
       if (res.ok) {
         const data = await res.json();
-        if (!mountedRef.current) return;
+        if (!mountedRef.current || isStale()) return;
         const s = data.session;
         setSession(
           s
             ? { ...s, prGithub: s.prGithub ?? null }
             : null,
         );
-      } else {
-        if (mountedRef.current) setSession(null);
+      } else if (!background && mountedRef.current) {
+        setSession(null);
       }
     } catch {
-      if (!mountedRef.current) return;
-      setSession(null);
+      if (!mountedRef.current || isStale()) return;
+      if (!background) setSession(null);
     }
-  }, []);
+  }, [beginLoadRequest, beginPollRequest]);
 
   useEffect(() => {
     void fetchSession();
   }, [fetchSession]);
 
+  usePeriodicSync({
+    enabled: syncEnabled,
+    intervalMs: GITHUB_SYNC_POLL_INTERVAL_MS,
+    onSync: () => fetchSession({ background: true }),
+    // マウント時の初回 fetchSession と即時 sync の二重 dispatch を回避（#929）
+    skipInitialSync: true,
+  });
+
   const saveFile = useCallback(
     async (
       path: string,
@@ -81,6 +115,8 @@ export function useEditSession() {
     ): Promise<SaveResult | null> => {
       setSaving(true);
       setError(null);
+      // mutation 中に in-flight の background poll が古い session を適用しないよう先行無効化（#935、IssueDetailView と同様）
+      beginPollRequest();
       try {
         const body: Record<string, unknown> = { content };
         if (sha) body.sha = sha;
@@ -109,11 +145,13 @@ export function useEditSession() {
         if (mountedRef.current) setSaving(false);
       }
     },
-    [fetchSession],
+    [fetchSession, beginPollRequest],
   );
 
   const createPr = useCallback(async (): Promise<string | null> => {
     setError(null);
+    // mutation 中に in-flight の background poll が古い session を適用しないよう先行無効化（#935、IssueDetailView と同様）
+    beginPollRequest();
     try {
       const res = await apiFetch("/pr/create", { method: "POST" });
       if (!res.ok) {
@@ -127,55 +165,7 @@ export function useEditSession() {
       if (mountedRef.current) setError(getErrorMessage(err, "PR の作成に失敗しました"));
       return null;
     }
-  }, [fetchSession]);
-
-  const submitPr = useCallback(async (): Promise<boolean> => {
-    setError(null);
-    try {
-      const res = await apiFetch("/pr/submit", { method: "POST" });
-      if (!res.ok) {
-        const detail = await res.json().catch(() => null);
-        throw new Error(detail?.detail ?? `Submit failed: ${res.status}`);
-      }
-      await fetchSession();
-      return true;
-    } catch (err) {
-      if (mountedRef.current) setError(getErrorMessage(err, "PR の提出に失敗しました"));
-      return false;
-    }
-  }, [fetchSession]);
-
-  const convertToDraft = useCallback(async (): Promise<boolean> => {
-    setError(null);
-    try {
-      const res = await apiFetch("/pr/draft", { method: "POST" });
-      if (!res.ok) {
-        const detail = await res.json().catch(() => null);
-        throw new Error(detail?.detail ?? `Draft conversion failed: ${res.status}`);
-      }
-      await fetchSession();
-      return true;
-    } catch (err) {
-      if (mountedRef.current) setError(getErrorMessage(err, "ドラフトへの変更に失敗しました"));
-      return false;
-    }
-  }, [fetchSession]);
-
-  const discardChanges = useCallback(async (): Promise<boolean> => {
-    setError(null);
-    try {
-      const res = await apiFetch("/pr/discard", { method: "POST" });
-      if (!res.ok) {
-        const detail = await res.json().catch(() => null);
-        throw new Error(detail?.detail ?? `Discard failed: ${res.status}`);
-      }
-      await fetchSession();
-      return true;
-    } catch (err) {
-      if (mountedRef.current) setError(getErrorMessage(err, "変更の破棄に失敗しました"));
-      return false;
-    }
-  }, [fetchSession]);
+  }, [fetchSession, beginPollRequest]);
 
   return {
     session,
@@ -183,9 +173,6 @@ export function useEditSession() {
     error,
     saveFile,
     createPr,
-    submitPr,
-    convertToDraft,
-    discardChanges,
     clearError: () => setError(null),
   };
 }

package/notes/app/src/hooks/useMdUpLayout.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from "vitest";
+import { resolvePanelWidthStyle } from "@/hooks/useMdUpLayout";
+
+describe("resolvePanelWidthStyle", () => {
+  it("デスクトップレイアウト時のみ幅スタイルを返す", () => {
+    expect(resolvePanelWidthStyle(320, true)).toEqual({ width: 320 });
+    expect(resolvePanelWidthStyle(320, false)).toBeUndefined();
+    expect(resolvePanelWidthStyle(undefined, true)).toBeUndefined();
+  });
+});

package/notes/app/src/hooks/useMdUpLayout.ts

@@ -0,0 +1,27 @@
+import { useEffect, useState } from "react";
+
+const MD_UP_QUERY = "(min-width: 768px)";
+
+export function useMdUpLayout(): boolean {
+  const [mdUp, setMdUp] = useState(() =>
+    typeof window !== "undefined" ? window.matchMedia(MD_UP_QUERY).matches : false,
+  );
+
+  useEffect(() => {
+    const media = window.matchMedia(MD_UP_QUERY);
+    const sync = () => setMdUp(media.matches);
+    sync();
+    media.addEventListener("change", sync);
+    return () => media.removeEventListener("change", sync);
+  }, []);
+
+  return mdUp;
+}
+
+export function resolvePanelWidthStyle(
+  width: number | undefined,
+  applyCustomWidth: boolean,
+): { width: number } | undefined {
+  if (!applyCustomWidth || width == null) return undefined;
+  return { width };
+}