@thaut/claude-ide 0.0.0-stage → 1.0.0

package/web/src/unsaved.tsx

@@ -0,0 +1,99 @@
+import { useCallback, useEffect, useId, useLayoutEffect, useRef } from "react";
+import { useBeforeUnload, useBlocker } from "react-router";
+import { create } from "zustand";
+import { useConfirm } from "./components/Confirmation.tsx";
+import { useDrafts } from "./drafts.ts";
+
+const useUnsaved = create<{ editors: Record<string, string> }>(() => ({ editors: {} }));
+let allowUnload = false;
+
+export function unsavedEditors() {
+  return [...new Set(Object.values(useUnsaved.getState().editors))];
+}
+export function hasPendingAttachments() {
+  return Object.values(useDrafts.getState().drafts).some((draft) => draft.images.length > 0 || draft.processing > 0);
+}
+/** A confirmed refresh must not immediately show a second, native confirmation. */
+export function allowNextUnload() {
+  allowUnload = true;
+  window.setTimeout(() => { allowUnload = false; }, 1000);
+}
+
+/** For changing local editor state without a URL change (for example config scope). */
+export function useDiscardEditors() {
+  const confirm = useConfirm();
+  return async () => {
+    const editors = unsavedEditors();
+    return !editors.length || (await confirm({
+      title: "放弃未保存的修改？",
+      description: `尚未保存：${editors.join("、")}。切换后这些修改会丢失。`,
+      confirmLabel: "放弃并切换",
+      cancelLabel: "继续编辑",
+      danger: true,
+    })).confirmed;
+  };
+}
+
+/** Register only edits that would be lost, not persisted conversation drafts. */
+export function useUnsavedChanges(dirty: boolean, label: string) {
+  const id = useId();
+  const confirm = useConfirm();
+  const markSaved = useCallback(() => {
+    useUnsaved.setState((state) => {
+      const { [id]: removed, ...editors } = state.editors;
+      return { editors };
+    });
+  }, [id]);
+  useLayoutEffect(() => {
+    if (dirty) useUnsaved.setState((state) => ({ editors: { ...state.editors, [id]: label } }));
+    return markSaved;
+  }, [id, dirty, label, markSaved]);
+  const discard = async () => {
+    const accepted = !dirty || (await confirm({
+      title: "放弃未保存的修改？",
+      description: `“${label}”尚未保存，放弃后这些修改会丢失。`,
+      confirmLabel: "放弃修改",
+      cancelLabel: "继续编辑",
+      danger: true,
+    })).confirmed;
+    if (accepted) markSaved();
+    return accepted;
+  };
+  return { discard, markSaved };
+}
+
+/** Router blocking covers links, programmatic navigation and browser back/forward. */
+export function UnsavedNavigationGuard() {
+  const editors = useUnsaved((state) => state.editors);
+  const confirm = useConfirm();
+  const blocker = useBlocker(({ currentLocation, nextLocation }) => (
+    Object.keys(useUnsaved.getState().editors).length > 0
+    && (currentLocation.pathname !== nextLocation.pathname || currentLocation.search !== nextLocation.search)
+  ));
+  const latest = useRef(blocker);
+  latest.current = blocker;
+  const asking = useRef(false);
+  useEffect(() => {
+    if (blocker.state !== "blocked" || asking.current) return;
+    asking.current = true;
+    void confirm({
+      title: "离开并放弃修改？",
+      description: `尚未保存：${unsavedEditors().join("、")}。离开后这些修改会丢失。`,
+      confirmLabel: "放弃并离开",
+      cancelLabel: "继续编辑",
+      danger: true,
+    }).then((answer) => {
+      if (latest.current.state === "blocked") {
+        if (answer.confirmed) latest.current.proceed();
+        else latest.current.reset();
+      }
+    }).finally(() => { asking.current = false; });
+  }, [blocker, editors, confirm]);
+  useBeforeUnload(useCallback((event: BeforeUnloadEvent) => {
+    if (allowUnload) { allowUnload = false; return; }
+    if (!unsavedEditors().length && !hasPendingAttachments()) return;
+    event.preventDefault();
+    event.returnValue = "";
+  }, []));
+  return null;
+}

package/web/src/user-text.test.ts

@@ -0,0 +1,60 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { splitUserText, userTextSummary } from "./user-text.ts";
+import { groupTurns } from "./turns.ts";
+
+test("speech warnings coexist with recognized speech, unheard text and ordinary text in order", () => {
+  const input = '前文<asr-recognized-text>关灯。</asr-recognized-text><asr-warning>\r\n背景噪声较大。\r\n</asr-warning><unheard_text reason="用户打断讲话">正在执行。</unheard_text>后文';
+  assert.deepEqual(splitUserText(input), [
+    { kind: "text", text: "前文" },
+    { kind: "asr-recognized-text", text: "关灯。" },
+    { kind: "asr-warning", text: "背景噪声较大。" },
+    { kind: "unheard_text", text: "正在执行。", reason: "用户打断讲话" },
+    { kind: "text", text: "后文" },
+  ]);
+});
+
+test("speech warning contents remain literal and repeated warnings stay separate", () => {
+  assert.deepEqual(splitUserText('<asr-warning source="asr">不要执行 <script>alert(1)</script></asr-warning><asr-warning>再确认一下。</asr-warning>'), [
+    { kind: "asr-warning", text: "不要执行 <script>alert(1)</script>" },
+    { kind: "asr-warning", text: "再确认一下。" },
+  ]);
+});
+
+test("unknown or unfinished speech tags are kept as ordinary text", () => {
+  for (const input of ["", "普通消息", "<asr-warning>未完成", "<asr-warning-extra>未知</asr-warning>", "<asr-warning>不匹配</unheard_text>"]) {
+    assert.deepEqual(splitUserText(input), [{ kind: "text", text: input }]);
+  }
+});
+
+test("turn summaries omit speech markup without rewriting the original user message", () => {
+  const text = "<asr-warning>\n识别结果可能不准确。\n</asr-warning><asr-recognized-text>请确认。 </asr-recognized-text>";
+  assert.equal(userTextSummary(text), "请确认。");
+  const item = { kind: "user" as const, key: "message", text, images: 0 };
+  const turn = groupTurns([item], false, true)[0]!;
+  assert.equal(turn.summary, "请确认。");
+  assert.equal(turn.items[0], item);
+  assert.equal(item.text, text);
+});
+
+test("turn preview prioritizes recognized user speech over interrupted playback and surrounding context", () => {
+  const speech = "好了，你看一下最新下载的文件。";
+  const text = `上下文说明<unheard_text reason="用户打断讲话">${"上一段未听到的回复。".repeat(30)}</unheard_text><asr-warning>有背景噪声。</asr-warning><asr-recognized-text>${speech}</asr-recognized-text>补充上下文`;
+  const item = { kind: "user" as const, key: "voice", text, images: 0 };
+  assert.equal(userTextSummary(text), speech);
+  assert.equal(groupTurns([item], false)[0]!.summary, speech);
+  assert.equal(item.text, text);
+  assert.equal(splitUserText(text).find((part) => part.kind === "unheard_text")?.text, "上一段未听到的回复。".repeat(30), "expanded content is retained");
+  assert.equal(userTextSummary("<asr-recognized-text>第一段。</asr-recognized-text><asr-warning>提示。</asr-warning><asr-recognized-text>\n第二段。\n</asr-recognized-text>"), "第一段。 第二段。");
+});
+
+test("without recognized speech, previews use ordinary text or a neutral input label", () => {
+  const metadata = '<unheard_text reason="用户打断讲话">旧回复。</unheard_text><asr-warning>识别提示。</asr-warning>';
+  assert.equal(userTextSummary(`${metadata} 普通用户消息\n第二行`), "普通用户消息 第二行");
+  assert.equal(userTextSummary(metadata), "");
+  assert.equal(userTextSummary("普通用户消息"), "普通用户消息");
+  for (const images of [0, 1]) {
+    const turn = groupTurns([{ kind: "user", key: "metadata", text: metadata, images }], false)[0]!;
+    assert.equal(turn.summary, images ? "图片输入" : "会话输入");
+  }
+});

package/web/src/user-text.ts

@@ -0,0 +1,35 @@
+export type UserTextPart =
+  | { kind: "text"; text: string }
+  | { kind: "asr-recognized-text"; text: string }
+  | { kind: "asr-warning"; text: string }
+  | { kind: "unheard_text"; text: string; reason?: string };
+
+/** Presentation only: the original prompt sent to the agent is never rewritten. */
+export function splitUserText(text: string): UserTextPart[] {
+  const parts: UserTextPart[] = [];
+  const tags = /<(asr-recognized-text|asr-warning|unheard_text)(?=[\s>])([^<>]*)>([\s\S]*?)<\/\1\s*>/g;
+  let from = 0;
+  for (const match of text.matchAll(tags)) {
+    if (match.index > from) parts.push({ kind: "text", text: text.slice(from, match.index) });
+    const content = match[3]!.replace(/^\r?\n|\r?\n$/g, "");
+    if (match[1] === "unheard_text") {
+      const reason = /(?:^|\s)reason\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(match[2]!);
+      parts.push({ kind: "unheard_text", text: content, reason: reason?.[1] ?? reason?.[2] });
+    } else if (match[1] === "asr-warning") {
+      parts.push({ kind: "asr-warning", text: content });
+    } else {
+      parts.push({ kind: "asr-recognized-text", text: content });
+    }
+    from = match.index + match[0].length;
+  }
+  if (from < text.length || !parts.length) parts.push({ kind: "text", text: text.slice(from) });
+  return parts;
+}
+
+export function userTextSummary(text: string): string {
+  const parts = splitUserText(text);
+  const speech = parts.filter((part) => part.kind === "asr-recognized-text" && part.text.trim());
+  // Preview the user's words, not interrupted playback or recognition warnings.
+  const preview = speech.length ? speech : parts.filter((part) => part.kind === "text");
+  return preview.map((part) => part.text).join(" ").replace(/\s+/g, " ").trim();
+}

package/web/src/uuid.ts

@@ -0,0 +1,12 @@
+/**
+ * RFC 4122 v4 UUID. `crypto.randomUUID` only exists in secure contexts (https/localhost);
+ * this app is normally opened over plain http on the LAN, where getRandomValues still works.
+ */
+export function uuid(): string {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  const b = crypto.getRandomValues(new Uint8Array(16));
+  b[6] = (b[6]! & 0x0f) | 0x40;
+  b[8] = (b[8]! & 0x3f) | 0x80;
+  const h = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.