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

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

@@ -0,0 +1,167 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  clampPanelWidth,
+  computeResizedWidth,
+  isRtlContext,
+  loadStoredPanelWidth,
+  PANEL_WIDTH_SAVE_DEBOUNCE_MS,
+  type ResizeEdge,
+  saveStoredPanelWidth,
+} from "@/lib/resizable-panel";
+
+type Options = {
+  storageKey: string;
+  defaultWidth: number;
+  minWidth: number;
+  maxWidth: number;
+  edge: ResizeEdge;
+};
+
+type ActiveDrag = {
+  handle: HTMLElement;
+  pointerId: number;
+  handleMove: (event: PointerEvent) => void;
+  handleUp: (event: PointerEvent) => void;
+};
+
+export function useResizablePanelWidth(options: Options) {
+  const { storageKey, defaultWidth, minWidth, maxWidth, edge } = options;
+  const [width, setWidth] = useState(() =>
+    loadStoredPanelWidth(storageKey, defaultWidth, minWidth, maxWidth),
+  );
+  const widthRef = useRef(width);
+  const storageKeyRef = useRef(storageKey);
+  const saveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const skipInitialSaveRef = useRef(true);
+  const lastSavedWidthRef = useRef<number | null>(null);
+  const activeDragRef = useRef<ActiveDrag | null>(null);
+
+  useEffect(() => {
+    storageKeyRef.current = storageKey;
+  }, [storageKey]);
+
+  useEffect(() => {
+    widthRef.current = width;
+  }, [width]);
+
+  const cancelSaveTimer = useCallback(() => {
+    if (saveTimerRef.current != null) {
+      clearTimeout(saveTimerRef.current);
+      saveTimerRef.current = null;
+    }
+  }, []);
+
+  const persistWidth = useCallback((nextWidth: number) => {
+    if (lastSavedWidthRef.current === nextWidth) return;
+    lastSavedWidthRef.current = nextWidth;
+    saveStoredPanelWidth(storageKeyRef.current, nextWidth);
+  }, []);
+
+  const flushSave = useCallback(() => {
+    cancelSaveTimer();
+    persistWidth(widthRef.current);
+  }, [cancelSaveTimer, persistWidth]);
+
+  useEffect(() => {
+    if (skipInitialSaveRef.current) {
+      skipInitialSaveRef.current = false;
+      lastSavedWidthRef.current = width;
+      return;
+    }
+    cancelSaveTimer();
+    saveTimerRef.current = setTimeout(() => {
+      persistWidth(width);
+      saveTimerRef.current = null;
+    }, PANEL_WIDTH_SAVE_DEBOUNCE_MS);
+    return cancelSaveTimer;
+  }, [storageKey, width, cancelSaveTimer, persistWidth]);
+
+  useEffect(() => {
+    const handleBeforeUnload = () => {
+      flushSave();
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      flushSave();
+
+      const drag = activeDragRef.current;
+      if (drag == null) return;
+
+      try {
+        drag.handle.releasePointerCapture(drag.pointerId);
+      } catch {
+        // pointer already released
+      }
+      document.body.style.cursor = "";
+      document.body.style.userSelect = "";
+      window.removeEventListener("pointermove", drag.handleMove);
+      window.removeEventListener("pointerup", drag.handleUp);
+      window.removeEventListener("pointercancel", drag.handleUp);
+      activeDragRef.current = null;
+    };
+  }, [flushSave]);
+
+  const onResizePointerDown = useCallback(
+    (event: React.PointerEvent<HTMLElement>) => {
+      event.preventDefault();
+      const handle = event.currentTarget;
+      handle.setPointerCapture(event.pointerId);
+
+      const startX = event.clientX;
+      const startWidth = widthRef.current;
+      // 書字方向はドラッグ中に変わらないため pointerdown 時に一度だけ判定する。
+      const rtl = isRtlContext(handle);
+
+      const handleMove = (moveEvent: PointerEvent) => {
+        const next = computeResizedWidth(
+          startWidth,
+          startX,
+          moveEvent.clientX,
+          edge,
+          minWidth,
+          maxWidth,
+          rtl,
+        );
+        widthRef.current = next;
+        setWidth(next);
+      };
+
+      const handleUp = (upEvent: PointerEvent) => {
+        handle.releasePointerCapture(upEvent.pointerId);
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+        window.removeEventListener("pointermove", handleMove);
+        window.removeEventListener("pointerup", handleUp);
+        window.removeEventListener("pointercancel", handleUp);
+        activeDragRef.current = null;
+        flushSave();
+      };
+
+      activeDragRef.current = {
+        handle,
+        pointerId: event.pointerId,
+        handleMove,
+        handleUp,
+      };
+
+      document.body.style.cursor = "col-resize";
+      document.body.style.userSelect = "none";
+      window.addEventListener("pointermove", handleMove);
+      window.addEventListener("pointerup", handleUp);
+      window.addEventListener("pointercancel", handleUp);
+    },
+    [edge, maxWidth, minWidth, flushSave],
+  );
+
+  const applyWidth = useCallback(
+    (next: number) => {
+      const clamped = clampPanelWidth(next, minWidth, maxWidth);
+      widthRef.current = clamped;
+      setWidth(clamped);
+    },
+    [maxWidth, minWidth],
+  );
+
+  return { width, onResizePointerDown, applyWidth };
+}

package/{notes-app → notes/app}/src/lib/api.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { getErrorMessage, isAbortError, getToken, setToken, clearToken, encodePath } from "./api";
+import { getErrorMessage, isAbortError, getToken, setToken, clearToken, encodePath, buildRequestSignal } from "./api";
 
 describe("getErrorMessage", () => {
   it("Error インスタンスからメッセージを取得する", () => {
@@ -229,6 +229,86 @@ describe("fetchSessionsApi", () => {
   });
 });
 
+describe("apiFetch signal 合成（デフォルトタイムアウト保持）", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    localStorage.clear();
+  });
+
+  it("caller signal を渡してもキャンセルが forward 先に伝播する", async () => {
+    const { fetchHistoryApi, setToken } = await import("./api");
+    setToken("test-token");
+    let captured: AbortSignal | null = null;
+    vi.spyOn(globalThis, "fetch").mockImplementation(
+      (_input: RequestInfo | URL, init?: RequestInit) => {
+        captured = init?.signal ?? null;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        );
+      },
+    );
+
+    const controller = new AbortController();
+    await fetchHistoryApi("docs/a.md", { signal: controller.signal });
+
+    expect(captured).not.toBeNull();
+    // タイムアウトと合成済みのため caller signal とは別インスタンス
+    expect(captured).not.toBe(controller.signal);
+    expect(captured!.aborted).toBe(false);
+    controller.abort();
+    expect(captured!.aborted).toBe(true);
+  });
+
+  it("caller signal なしでもタイムアウト signal が forward される", async () => {
+    const { fetchHistoryApi, setToken } = await import("./api");
+    setToken("test-token");
+    let captured: AbortSignal | null = null;
+    vi.spyOn(globalThis, "fetch").mockImplementation(
+      (_input: RequestInfo | URL, init?: RequestInit) => {
+        captured = init?.signal ?? null;
+        return Promise.resolve(
+          new Response(JSON.stringify([]), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }),
+        );
+      },
+    );
+
+    await fetchHistoryApi("docs/a.md");
+    expect(captured).toBeInstanceOf(AbortSignal);
+  });
+});
+
+describe("buildRequestSignal", () => {
+  it("signal なしのときタイムアウト signal を返す", () => {
+    const signal = buildRequestSignal(undefined, 10_000);
+    expect(signal).toBeInstanceOf(AbortSignal);
+    expect(signal.aborted).toBe(false);
+  });
+
+  it("caller signal を合成し、caller の abort が伝播する", () => {
+    const controller = new AbortController();
+    const signal = buildRequestSignal(controller.signal, 10_000);
+    expect(signal).not.toBe(controller.signal);
+    expect(signal.aborted).toBe(false);
+    controller.abort();
+    expect(signal.aborted).toBe(true);
+  });
+
+  it("タイムアウトが経過すると合成 signal が abort する", async () => {
+    const controller = new AbortController();
+    const signal = buildRequestSignal(controller.signal, 10);
+    expect(signal.aborted).toBe(false);
+    await new Promise((resolve) => setTimeout(resolve, 60));
+    expect(signal.aborted).toBe(true);
+    expect(controller.signal.aborted).toBe(false); // caller 側は abort されない
+  });
+});
+
 describe("encodePath", () => {
   it("encodes special characters in path segments", () => {
     expect(encodePath("docs/my file.md")).toBe("docs/my%20file.md");

package/{notes-app → notes/app}/src/lib/api.ts

@@ -34,6 +34,18 @@ async function refreshToken(): Promise<string | null> {
   return newToken;
 }
 
+/**
+ * caller が signal を渡しても、デフォルトタイムアウトを失わないよう合成する。
+ * caller のキャンセル / タイムアウトのどちらか一方が abort すれば合成 signal も abort される。
+ */
+export function buildRequestSignal(
+  callerSignal: AbortSignal | null | undefined,
+  timeoutMs: number,
+): AbortSignal {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  return callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+}
+
 export async function apiFetch(
   path: string,
   init: RequestInit = {},
@@ -44,7 +56,7 @@ export async function apiFetch(
     headers.set("Authorization", `Bearer ${token}`);
   }
 
-  const signal = init.signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+  const signal = buildRequestSignal(init.signal, DEFAULT_TIMEOUT_MS);
 
   let res = await fetch(`${API_BASE}${path}`, {
     ...init,
@@ -232,8 +244,11 @@ export type CommitEntry = {
   date: string;
 };
 
-export async function fetchHistoryApi(path: string): Promise<CommitEntry[]> {
-  const res = await apiFetch(`/history/${encodePath(path)}`);
+export async function fetchHistoryApi(
+  path: string,
+  options: { signal?: AbortSignal } = {},
+): Promise<CommitEntry[]> {
+  const res = await apiFetch(`/history/${encodePath(path)}`, { signal: options.signal });
   if (!res.ok) {
     const body = await res.json().catch(() => null);
     throw new Error(formatApiDetail(body, `Failed to fetch history: ${res.status}`));
@@ -437,6 +452,7 @@ export async function fetchProposalsApi(): Promise<Proposal[]> {
 export type IssueLabel = {
   name: string;
   color: string;
+  description?: string;
 };
 
 export type IssueSummary = {
@@ -470,11 +486,19 @@ export type IssueUpdateInput = {
 };
 
 export async function listIssuesApi(
-  params: { state?: string; labels?: string; page?: number; per_page?: number; signal?: AbortSignal } = {},
+  params: {
+    state?: string;
+    labels?: string;
+    assignee?: string;
+    page?: number;
+    per_page?: number;
+    signal?: AbortSignal;
+  } = {},
 ): Promise<{ issues: IssueSummary[] }> {
   const q = new URLSearchParams();
   if (params.state) q.set("state", params.state);
   if (params.labels) q.set("labels", params.labels);
+  if (params.assignee) q.set("assignee", params.assignee);
   if (params.page) q.set("page", String(params.page));
   if (params.per_page) q.set("per_page", String(params.per_page));
   const qs = q.toString();
@@ -524,6 +548,42 @@ export async function updateIssueApi(
   return res.json();
 }
 
+export type IssueComment = {
+  id: number;
+  body: string;
+  author: string;
+  createdAt: string;
+  updatedAt: string;
+  url: string;
+};
+
+export async function listIssueCommentsApi(
+  number: number,
+): Promise<{ comments: IssueComment[] }> {
+  const res = await apiFetch(`/issues/${number}/comments`);
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    throw new Error(formatApiDetail(body, `Failed to list issue comments: ${res.status}`));
+  }
+  return res.json();
+}
+
+export async function createIssueCommentApi(
+  number: number,
+  body: string,
+): Promise<IssueComment> {
+  const res = await apiFetch(`/issues/${number}/comments`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ body }),
+  });
+  if (!res.ok) {
+    const resBody = await res.json().catch(() => null);
+    throw new Error(formatApiDetail(resBody, `Failed to post issue comment: ${res.status}`));
+  }
+  return res.json();
+}
+
 export async function listIssueLabelsApi(): Promise<{ labels: IssueLabel[] }> {
   const res = await apiFetch("/issues/labels");
   if (!res.ok) {
@@ -552,6 +612,40 @@ export async function createLabelApi(input: LabelCreateInput): Promise<IssueLabe
   return res.json();
 }
 
+export type LabelUpdateInput = {
+  new_name?: string;
+  color?: string;
+  description?: string;
+};
+
+function labelPath(name: string): string {
+  return `/issues/labels/${encodeURIComponent(name)}`;
+}
+
+export async function updateLabelApi(
+  name: string,
+  input: LabelUpdateInput,
+): Promise<IssueLabel> {
+  const res = await apiFetch(labelPath(name), {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    throw new Error(formatApiDetail(body, `Failed to update label: ${res.status}`));
+  }
+  return res.json();
+}
+
+export async function deleteLabelApi(name: string): Promise<void> {
+  const res = await apiFetch(labelPath(name), { method: "DELETE" });
+  if (!res.ok) {
+    const body = await res.json().catch(() => null);
+    throw new Error(formatApiDetail(body, `Failed to delete label: ${res.status}`));
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Comments
 // ---------------------------------------------------------------------------

package/notes/app/src/lib/commentAnchor.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import { anchorFromPlainTextSelection } from "./commentAnchor";
+
+describe("anchorFromPlainTextSelection", () => {
+  it("returns anchor with positions when selection exists in full text", () => {
+    const full = "Hello world";
+    const result = anchorFromPlainTextSelection(full, "world");
+    expect(result).toEqual({
+      anchor_text: "world",
+      position_from: 6,
+      position_to: 11,
+    });
+  });
+
+  it("returns null for empty selection", () => {
+    expect(anchorFromPlainTextSelection("Hello", "   ")).toBeNull();
+  });
+
+  it("returns null when selection is not found in full text", () => {
+    expect(anchorFromPlainTextSelection("Hello", "missing")).toBeNull();
+  });
+});

package/notes/app/src/lib/commentAnchor.ts

@@ -0,0 +1,28 @@
+export type CommentAnchor = {
+  anchor_text: string;
+  position_from: number;
+  position_to: number;
+};
+
+export function anchorFromPlainTextSelection(
+  fullText: string,
+  selectedText: string,
+): CommentAnchor | null {
+  const anchor_text = selectedText.trim();
+  if (!anchor_text) return null;
+
+  const position_from = fullText.indexOf(anchor_text);
+  if (position_from === -1) return null;
+
+  return {
+    anchor_text,
+    position_from,
+    position_to: position_from + anchor_text.length,
+  };
+}
+
+export function getWindowSelectionAnchor(fullText: string): CommentAnchor | null {
+  const selection = window.getSelection();
+  if (!selection || selection.isCollapsed) return null;
+  return anchorFromPlainTextSelection(fullText, selection.toString());
+}

package/notes/app/src/lib/commentHighlight.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import { Schema } from "@tiptap/pm/model";
+import { buildHighlightDecorations, textOffsetToPos } from "@/lib/commentHighlight";
+import type { CommentAnchor } from "@/lib/commentAnchor";
+
+const schema = new Schema({
+  nodes: {
+    doc: { content: "block+" },
+    paragraph: { content: "inline*", group: "block" },
+    text: { group: "inline" },
+  },
+});
+
+function paragraph(text: string) {
+  return schema.node("paragraph", null, text ? [schema.text(text)] : undefined);
+}
+
+function docFromParagraphs(...lines: string[]) {
+  return schema.node("doc", null, lines.map(paragraph));
+}
+
+function plainText(doc: ReturnType<typeof docFromParagraphs>): string {
+  return doc.textBetween(0, doc.content.size, "\n");
+}
+
+describe("textOffsetToPos", () => {
+  it("単一段落内の offset を ProseMirror 位置に変換する", () => {
+    const doc = docFromParagraphs("Hello world");
+    const text = plainText(doc);
+
+    expect(textOffsetToPos(doc, 0)).toBe(0);
+    expect(doc.textBetween(0, textOffsetToPos(doc, 6)!, "\n")).toBe("Hello ");
+    const endPos = textOffsetToPos(doc, text.length);
+    expect(endPos).not.toBeNull();
+    expect(doc.textBetween(0, endPos!, "\n")).toBe(text);
+  });
+
+  it("段落境界の \\n を plain-text offset に含める", () => {
+    const doc = docFromParagraphs("Line one", "Line two");
+    const text = plainText(doc);
+    const secondLineStart = text.indexOf("Line two");
+
+    expect(secondLineStart).toBeGreaterThan(0);
+    expect(text[secondLineStart - 1]).toBe("\n");
+    expect(textOffsetToPos(doc, secondLineStart)).not.toBeNull();
+    expect(
+      doc.textBetween(0, textOffsetToPos(doc, secondLineStart)!, "\n"),
+    ).toBe(text.slice(0, secondLineStart));
+  });
+
+  it("範囲外 offset は null を返す", () => {
+    const doc = docFromParagraphs("Hello");
+    expect(textOffsetToPos(doc, -1)).toBeNull();
+    expect(textOffsetToPos(doc, plainText(doc).length + 1)).toBeNull();
+  });
+});
+
+describe("buildHighlightDecorations", () => {
+  it("有効なアンカー範囲に decoration を付与する", () => {
+    const doc = docFromParagraphs("Hello world");
+    const highlights: CommentAnchor[] = [
+      {
+        anchor_text: "world",
+        position_from: 6,
+        position_to: 11,
+      },
+    ];
+
+    const from = textOffsetToPos(doc, highlights[0].position_from);
+    const to = textOffsetToPos(doc, highlights[0].position_to);
+    expect(doc.textBetween(from!, to!, "\n")).toBe("world");
+
+    const set = buildHighlightDecorations(doc, highlights);
+    expect(set.find(0, doc.content.size).length).toBe(1);
+  });
+
+  it("2 段落目のアンカーを正しい位置にハイライトする", () => {
+    const doc = docFromParagraphs("First paragraph", "Second target");
+    const text = plainText(doc);
+    const from = text.indexOf("target");
+    const to = from + "target".length;
+
+    const startPos = textOffsetToPos(doc, from);
+    const endPos = textOffsetToPos(doc, to);
+    expect(doc.textBetween(startPos!, endPos!, "\n")).toBe("target");
+
+    const set = buildHighlightDecorations(doc, [
+      {
+        anchor_text: "target",
+        position_from: from,
+        position_to: to,
+      },
+    ]);
+
+    expect(set.find(0, doc.content.size).length).toBe(1);
+  });
+
+  it("無効な offset は decoration を作らない", () => {
+    const doc = docFromParagraphs("Hello");
+    const set = buildHighlightDecorations(doc, [
+      {
+        anchor_text: "missing",
+        position_from: 100,
+        position_to: 107,
+      },
+    ]);
+
+    expect(set.find(0, doc.content.size).length).toBe(0);
+  });
+});

package/notes/app/src/lib/commentHighlight.ts

@@ -0,0 +1,44 @@
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import type { Node as ProseMirrorNode } from "@tiptap/pm/model";
+import type { CommentAnchor } from "@/lib/commentAnchor";
+
+const PLAIN_TEXT_BLOCK_SEPARATOR = "\n";
+
+/**
+ * Maps a plain-text offset (same convention as `doc.textBetween(0, pos, "\\n")`)
+ * to a ProseMirror document position.
+ */
+export function textOffsetToPos(doc: ProseMirrorNode, targetOffset: number): number | null {
+  if (targetOffset < 0) return null;
+
+  const maxPos = doc.content.size;
+  for (let pos = 0; pos <= maxPos; pos++) {
+    if (doc.textBetween(0, pos, PLAIN_TEXT_BLOCK_SEPARATOR).length === targetOffset) {
+      return pos;
+    }
+  }
+
+  return null;
+}
+
+export function buildHighlightDecorations(
+  doc: ProseMirrorNode,
+  highlights: CommentAnchor[],
+): DecorationSet {
+  const decorations: Decoration[] = [];
+
+  for (const highlight of highlights) {
+    const from = textOffsetToPos(doc, highlight.position_from);
+    const to = textOffsetToPos(doc, highlight.position_to);
+    if (from != null && to != null && from < to) {
+      decorations.push(
+        Decoration.inline(from, to, {
+          class: "comment-anchor-highlight",
+          title: highlight.anchor_text,
+        }),
+      );
+    }
+  }
+
+  return DecorationSet.create(doc, decorations);
+}