wave-code 1.1.5 → 1.3.0

package/src/components/PluginManagerTypes.ts

@@ -24,6 +24,8 @@ export interface PluginManagerState {
 export interface PluginManagerContextType {
   state: PluginManagerState;
   marketplaces: KnownMarketplace[];
+  /** 打开插件管理器触发的后台清单刷新是否仍在进行（只拉检出、不升级插件）。 */
+  checkingForUpdates: boolean;
   installedPlugins: (InstalledPlugin & { enabled: boolean })[];
   discoverablePlugins: (MarketplacePluginEntry & {
     marketplace: string;
@@ -49,7 +51,6 @@ export interface PluginManagerContextType {
     ) => Promise<void>;
     uninstallPlugin: (name: string, marketplace: string) => Promise<void>;
     updatePlugin: (name: string, marketplace: string) => Promise<void>;
-    toggleAutoUpdate: (name: string, enabled: boolean) => Promise<void>;
     refresh: () => Promise<void>;
     clearPluginFeedback: () => void;
   };

package/src/components/ResumeCommand.tsx

@@ -0,0 +1,84 @@
+import React, { useEffect, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { SessionSelectorFlow } from "./SessionSelectorFlow.js";
+import { listWorktrees } from "../utils/worktree.js";
+
+export interface ResumeCommandProps {
+  /** The session's current working directory (the picker's default scope). */
+  workdir: string;
+  /**
+   * True while a turn is in flight. Switching mid-turn is refused: the running
+   * turn must not be aborted (its abort error would land in the session being
+   * left behind), so the picker is replaced by a notice.
+   */
+  isBusy: boolean;
+  /**
+   * Called with the chosen session. `resumeWorkdir` is set when the session
+   * belongs to a sibling worktree of the same repo — the session then moves
+   * into that directory.
+   */
+  onSelect: (sessionId: string, resumeWorkdir?: string) => void;
+  onCancel: () => void;
+}
+
+/**
+ * In-TUI `/resume` picker. Thin wrapper over the shared `SessionSelectorFlow`:
+ * the worktree list is loaded lazily on open (it needs a `git worktree list`
+ * round-trip), and a cross-project selection shows a dismissible notice instead
+ * of tearing down the TUI.
+ */
+export const ResumeCommand: React.FC<ResumeCommandProps> = ({
+  workdir,
+  isBusy,
+  onSelect,
+  onCancel,
+}) => {
+  const [worktreePaths, setWorktreePaths] = useState<string[] | null>(null);
+
+  useInput((_input, key) => {
+    if (isBusy && key.escape) {
+      onCancel();
+    }
+  });
+
+  useEffect(() => {
+    if (isBusy) return;
+    let cancelled = false;
+    listWorktrees(workdir).then((paths) => {
+      if (!cancelled) setWorktreePaths(paths);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [workdir, isBusy]);
+
+  if (isBusy) {
+    return (
+      <Box flexDirection="column" paddingX={1}>
+        <Text color="yellow">
+          Cannot resume a conversation while the agent is running.
+        </Text>
+        <Text dimColor>Esc to go back</Text>
+      </Box>
+    );
+  }
+
+  if (!worktreePaths) {
+    return (
+      <Box paddingX={1}>
+        <Text dimColor>Loading conversations…</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <SessionSelectorFlow
+      currentWorkdir={workdir}
+      worktreePaths={worktreePaths}
+      crossProjectMode="dismiss"
+      onDone={(result) =>
+        result ? onSelect(result.sessionId, result.resumeWorkdir) : onCancel()
+      }
+    />
+  );
+};

package/src/components/ScrolledContent.tsx

@@ -0,0 +1,71 @@
+import React, { useLayoutEffect, useRef } from "react";
+import { Box, type DOMElement } from "ink";
+
+export interface ScrolledContentProps {
+  /** Every content row — rows are never sliced, the viewport clips them. */
+  children: React.ReactNode;
+  /** Largest height the viewport may take, in terminal rows (the row budget
+   *  for the content area). Shorter content keeps its natural height. */
+  visibleRows: number;
+  /** Rows scrolled off the top. */
+  scrollOffset: number;
+  /** Reports the content height in terminal rows, re-reporting on change. */
+  onMeasuredRows: (rows: number) => void;
+}
+
+/**
+ * Hard-bounded, clipping viewport for content that can be wider than the
+ * terminal: the content is rendered once and translated up by `scrollOffset`
+ * rows, and rows outside the viewport are clipped away.
+ *
+ * Height is bounded by construction — a line that wraps grows the content
+ * instead of the frame — so the row budget of the surrounding layout holds no
+ * matter how many rows the content really needs.
+ *
+ * The row count is read back from the layout rather than predicted from the
+ * text: by the time this effect runs, Yoga has wrapped the content to the
+ * terminal width, so the computed height already includes wrapped rows.
+ */
+export const ScrolledContent: React.FC<ScrolledContentProps> = ({
+  children,
+  visibleRows,
+  scrollOffset,
+  onMeasuredRows,
+}) => {
+  const contentRef = useRef<DOMElement | null>(null);
+  const reportedRows = useRef(0);
+
+  useLayoutEffect(() => {
+    const yogaNode = contentRef.current?.yogaNode;
+    if (!yogaNode) {
+      return;
+    }
+    const rows = Math.round(yogaNode.getComputedHeight());
+    if (rows > 0 && rows !== reportedRows.current) {
+      reportedRows.current = rows;
+      onMeasuredRows(rows);
+    }
+  });
+
+  return (
+    <Box
+      maxHeight={visibleRows}
+      overflow="hidden"
+      flexShrink={0}
+      flexDirection="column"
+    >
+      <Box
+        ref={contentRef}
+        flexDirection="column"
+        // Without this the fixed-height parent shrinks the content to fit and
+        // renders garbled rows instead of clipping them.
+        flexShrink={0}
+        marginTop={-scrollOffset}
+      >
+        {children}
+      </Box>
+    </Box>
+  );
+};
+
+ScrolledContent.displayName = "ScrolledContent";

package/src/components/SessionSelector.tsx

@@ -1,5 +1,11 @@
-import React, { useReducer, useEffect, useRef } from "react";
-import { Box, Text, useInput } from "ink";
+import React, {
+  useReducer,
+  useEffect,
+  useRef,
+  useState,
+  useCallback,
+} from "react";
+import { Box, Text, useInput, type Key } from "ink";
 import type { SessionMetadata } from "wave-agent-sdk";
 import {
   selectorReducer,
@@ -23,8 +29,22 @@ export interface SessionSelectorProps {
   onToggleAllProjects?: (showAllProjects: boolean) => void;
   /** Emitted with the new scope when the user toggles all-worktrees (Ctrl+W). */
   onToggleAllWorktrees?: (showAllWorktrees: boolean) => void;
+  /**
+   * Ctrl+R renames the focused session. The parent persists the new title
+   * (the session may belong to another project, so only it knows the file);
+   * the row shows the new title as soon as the promise resolves. Rejecting
+   * keeps the old title and surfaces a visible failure notice.
+   */
+  onRename?: (sessionId: string, title: string) => Promise<void>;
 }
 
+type RenameState = {
+  sessionId: string;
+  value: string;
+  cursor: number;
+  saving: boolean;
+};
+
 export const SessionSelector: React.FC<SessionSelectorProps> = ({
   sessions,
   onSelect,
@@ -33,6 +53,7 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
   showProjectPath = false,
   onToggleAllProjects,
   onToggleAllWorktrees,
+  onRename,
 }) => {
   const [state, dispatch] = useReducer(selectorReducer<SessionItem>, {
     selectedIndex: 0,
@@ -50,12 +71,113 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
     showAllWorktrees,
   } = state;
 
+  // Titles committed during this picker session. The parent's list is only
+  // re-synced through SET_ITEMS (which resets the selection), so overlaying the
+  // new title here keeps the row, the scope and the selected index intact.
+  const [renamedTitles, setRenamedTitles] = useState<Record<string, string>>(
+    {},
+  );
+  const [renaming, setRenaming] = useState<RenameState | null>(null);
+  const [renameError, setRenameError] = useState<string | null>(null);
+
   // Sync sessions into reducer state
   useEffect(() => {
     dispatch({ type: "SET_ITEMS", items: sessions });
   }, [sessions]);
 
+  const submitRename = useCallback(async () => {
+    if (!renaming || renaming.saving) return;
+    const { sessionId, value } = renaming;
+    const title = value.trim();
+    // Blank title: nothing to save, just leave the editor (spec: 空标题为 no-op).
+    if (!title) {
+      setRenaming(null);
+      return;
+    }
+    setRenaming({ ...renaming, saving: true });
+    try {
+      await onRename?.(sessionId, title);
+      setRenamedTitles((prev) => ({ ...prev, [sessionId]: title }));
+      setRenameError(null);
+      setRenaming(null);
+    } catch (error) {
+      setRenaming(null);
+      setRenameError(
+        `Failed to rename: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }, [renaming, onRename]);
+
+  const handleRenameKeys = (input: string, key: Key) => {
+    // While saving, swallow everything — the editor closes on the response.
+    if (!renaming || renaming.saving) return;
+
+    if (key.escape) {
+      setRenaming(null);
+      return;
+    }
+    if (key.return) {
+      void submitRename();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (renaming.cursor === 0) return;
+      const nextCursor = renaming.cursor - 1;
+      setRenaming({
+        ...renaming,
+        value:
+          renaming.value.slice(0, nextCursor) +
+          renaming.value.slice(renaming.cursor),
+        cursor: nextCursor,
+      });
+      return;
+    }
+    if (key.leftArrow) {
+      setRenaming({
+        ...renaming,
+        cursor: Math.max(0, renaming.cursor - 1),
+      });
+      return;
+    }
+    if (key.rightArrow) {
+      setRenaming({
+        ...renaming,
+        cursor: Math.min(renaming.value.length, renaming.cursor + 1),
+      });
+      return;
+    }
+    if (
+      input &&
+      !key.ctrl &&
+      !key.meta &&
+      !key.return &&
+      !key.escape &&
+      !key.backspace &&
+      !key.delete &&
+      !key.leftArrow &&
+      !key.rightArrow
+    ) {
+      setRenaming({
+        ...renaming,
+        value:
+          renaming.value.slice(0, renaming.cursor) +
+          input +
+          renaming.value.slice(renaming.cursor),
+        cursor: renaming.cursor + input.length,
+      });
+    }
+  };
+
+  // One subscription for both modes: while the inline title editor is open it
+  // owns every key (spec: 编辑期间按键不得冒泡触发列表操作), so a single handler
+  // keeps the editor from racing a second `useInput` subscription.
   useInput((input, key) => {
+    if (renaming) {
+      handleRenameKeys(input, key);
+      return;
+    }
     // Ctrl+A — toggle all-projects scope (only when the parent supports it)
     if (key.ctrl && input.toLowerCase() === "a" && onToggleAllProjects) {
       dispatch({ type: "TOGGLE_ALL_PROJECTS" });
@@ -71,6 +193,24 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
       dispatch({ type: "TOGGLE_ALL_WORKTREES" });
       return;
     }
+    // Ctrl+R — rename the focused session in place
+    if (key.ctrl && input.toLowerCase() === "r" && onRename) {
+      const target = items[selectedIndex];
+      if (!target) return;
+      const initial =
+        renamedTitles[target.id] ??
+        target.customTitle ??
+        target.firstMessage ??
+        "";
+      setRenameError(null);
+      setRenaming({
+        sessionId: target.id,
+        value: initial,
+        cursor: initial.length,
+        saving: false,
+      });
+      return;
+    }
     dispatch({ type: "HANDLE_KEY", key, hasInsert: false });
   });
 
@@ -135,6 +275,14 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
     startIndex + MAX_VISIBLE_ITEMS,
   );
 
+  // Display precedence: custom title > first message > placeholder (shared with
+  // every other host — spec: session-management.md 用户故事「会话自定义标题」).
+  const sessionTitle = (session: SessionItem): string =>
+    renamedTitles[session.id] ??
+    session.customTitle ??
+    session.firstMessage ??
+    "";
+
   const hints = [
     onToggleAllProjects
       ? `Ctrl+A ${showAllProjects ? "current directory" : "all projects"}`
@@ -142,6 +290,7 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
     onToggleAllWorktrees && worktreePaths.length > 1
       ? `Ctrl+W ${showAllWorktrees ? "current worktree" : "all worktrees"}`
       : null,
+    onRename ? "Ctrl+R rename" : null,
     "↑↓ select",
     "Enter confirm",
     "Esc cancel",
@@ -171,6 +320,7 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
           const actualIndex = startIndex + index;
           const isSelected = actualIndex === selectedIndex;
           const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
+          const isRenaming = renaming?.sessionId === session.id;
 
           return (
             <Box key={session.id} flexDirection="column" width="100%">
@@ -200,12 +350,28 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
                   </Text>
                 </Box>
               </Box>
-              {isSelected && session.firstMessage && (
+              {isRenaming && renaming ? (
                 <Box marginLeft={2} width="100%">
-                  <Text dimColor italic wrap="truncate-end">
-                    {session.firstMessage.replace(/\n/g, "\\n")}
+                  <Text>
+                    <Text dimColor>Rename: </Text>
+                    {renaming.value.slice(0, renaming.cursor)}
+                    <Text backgroundColor="white" color="black">
+                      {renaming.cursor < renaming.value.length
+                        ? renaming.value[renaming.cursor]
+                        : " "}
+                    </Text>
+                    {renaming.value.slice(renaming.cursor + 1)}
                   </Text>
                 </Box>
+              ) : (
+                isSelected &&
+                sessionTitle(session) && (
+                  <Box marginLeft={2} width="100%">
+                    <Text dimColor italic wrap="truncate-end">
+                      {sessionTitle(session).replace(/\n/g, "\\n")}
+                    </Text>
+                  </Box>
+                )
               )}
             </Box>
           );
@@ -220,8 +386,20 @@ export const SessionSelector: React.FC<SessionSelectorProps> = ({
         </Box>
       )}
 
+      {renameError && (
+        <Box>
+          <Text color="red">{renameError}</Text>
+        </Box>
+      )}
+
       <Box>
-        <Text dimColor>{hints}</Text>
+        <Text dimColor>
+          {renaming
+            ? renaming.saving
+              ? "Saving…"
+              : "Enter save  ·  Esc cancel"
+            : hints}
+        </Text>
       </Box>
     </Box>
   );

package/src/components/SessionSelectorFlow.tsx

@@ -0,0 +1,246 @@
+import React, { useState, useCallback, useEffect, useRef } from "react";
+import { Box, Text, useInput } from "ink";
+import {
+  listSessions,
+  listAllSessions,
+  setSessionCustomTitle,
+  truncateContent,
+  type SessionMetadata,
+} from "wave-agent-sdk";
+import { SessionSelector } from "./SessionSelector.js";
+import { setClipboardText } from "../utils/clipboard.js";
+import { resolveSessionOwnership } from "../utils/sessionOwnership.js";
+
+export interface SessionSelectorResult {
+  sessionId: string;
+  /**
+   * When the selected session belongs to a sibling git worktree of the same
+   * repo, the caller should chdir into this path before restoring.
+   */
+  resumeWorkdir?: string;
+}
+
+type SessionItem = SessionMetadata & { firstMessage?: string };
+
+/**
+ * Interactive session picker.
+ *
+ * Three scopes, toggled with Ctrl+A / Ctrl+W (mirroring Claude Code's resume
+ * picker):
+ * - current:   sessions in the current working directory (default)
+ * - worktrees: sessions in any worktree of the same git repository
+ * - all:       sessions across every project directory
+ *
+ * Resume decision on selection:
+ * - current dir session      → resume in place
+ * - same-repo worktree       → resume after chdir into that worktree
+ * - other project            → print `cd <path> && wave --restore <id>`,
+ *                              copy it to the clipboard, and finish
+ *
+ * Shared by `wave -r` (own Ink render) and the in-TUI `/resume` command, so
+ * the two can never drift in scopes or ownership resolution.
+ */
+export function SessionSelectorFlow({
+  currentWorkdir,
+  worktreePaths,
+  onDone,
+  crossProjectMode = "exit",
+}: {
+  currentWorkdir: string;
+  worktreePaths: string[];
+  onDone: (result: SessionSelectorResult | null) => void;
+  /**
+   * What happens after the cross-project `cd` command is shown:
+   * - "exit": finish the flow (the standalone `wave -r` picker then prints the
+   *   command and the process exits).
+   * - "dismiss": stay in the flow until Esc — used by the in-TUI `/resume`
+   *   picker, which must not tear down the surrounding conversation.
+   */
+  crossProjectMode?: "exit" | "dismiss";
+}): React.ReactNode {
+  const [showAllProjects, setShowAllProjects] = useState(false);
+  const [showAllWorktrees, setShowAllWorktrees] = useState(false);
+  const [sessions, setSessions] = useState<SessionItem[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [crossProjectCommand, setCrossProjectCommand] = useState<string | null>(
+    null,
+  );
+
+  // Mirror of the scope flags for use inside async reload/decision callbacks.
+  const scopeRef = useRef({ showAllProjects: false, showAllWorktrees: false });
+
+  const loadSessions = useCallback(
+    async (allProjects: boolean, allWorktrees: boolean) => {
+      if (allProjects) {
+        return listAllSessions();
+      }
+      if (allWorktrees) {
+        return listAllSessions({ worktreePaths, workdir: currentWorkdir });
+      }
+      return listSessions(currentWorkdir);
+    },
+    [worktreePaths, currentWorkdir],
+  );
+
+  const reload = useCallback(
+    async (allProjects: boolean, allWorktrees: boolean) => {
+      setLoading(true);
+      try {
+        const result = await loadSessions(allProjects, allWorktrees);
+        setSessions(
+          result.map((s) => ({
+            ...s,
+            firstMessage: truncateContent(s.firstMessage || "No content", 80),
+          })),
+        );
+      } finally {
+        setLoading(false);
+      }
+    },
+    [loadSessions],
+  );
+
+  // Initial load: current directory scope
+  useEffect(() => {
+    void reload(false, false);
+  }, [reload]);
+
+  const handleToggleAllProjects = useCallback(
+    (value: boolean) => {
+      scopeRef.current.showAllProjects = value;
+      setShowAllProjects(value);
+      void reload(value, scopeRef.current.showAllWorktrees);
+    },
+    [reload],
+  );
+
+  const handleToggleAllWorktrees = useCallback(
+    (value: boolean) => {
+      scopeRef.current.showAllWorktrees = value;
+      setShowAllWorktrees(value);
+      void reload(scopeRef.current.showAllProjects, value);
+    },
+    [reload],
+  );
+
+  const handleSelect = useCallback(
+    async (sessionId: string) => {
+      const session = sessions.find((s) => s.id === sessionId);
+      if (!session) return;
+
+      const ownership = await resolveSessionOwnership(session, {
+        worktreePaths,
+        currentWorkdir,
+      });
+
+      switch (ownership.kind) {
+        case "current":
+          onDone({ sessionId });
+          return;
+        case "worktree":
+          onDone({ sessionId, resumeWorkdir: ownership.resumeWorkdir });
+          return;
+        case "cross-project":
+          // Different project — show the cd command instead of resuming in place
+          await setClipboardText(ownership.command);
+          setCrossProjectCommand(ownership.command);
+          return;
+      }
+    },
+    [sessions, worktreePaths, currentWorkdir, onDone],
+  );
+
+  // Ctrl+R rename. The session may belong to another project (or a sibling
+  // worktree), so the write is addressed by the session's own workdir — the
+  // SDK falls back to scanning every project directory when that path no
+  // longer matches. Rejections bubble up so the picker can show the failure.
+  const handleRename = useCallback(
+    async (sessionId: string, title: string) => {
+      const session = sessions.find((s) => s.id === sessionId);
+      await setSessionCustomTitle(
+        sessionId,
+        session?.workdir ?? currentWorkdir,
+        title,
+      );
+    },
+    [sessions, currentWorkdir],
+  );
+
+  if (crossProjectCommand) {
+    return (
+      <CrossProjectMessage
+        command={crossProjectCommand}
+        onExit={() =>
+          crossProjectMode === "dismiss"
+            ? setCrossProjectCommand(null)
+            : onDone(null)
+        }
+        autoExit={crossProjectMode === "exit"}
+      />
+    );
+  }
+
+  if (loading) {
+    return (
+      <Box>
+        <Text dimColor>Loading conversations…</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box padding={1}>
+      <SessionSelector
+        sessions={sessions}
+        worktreePaths={worktreePaths}
+        showProjectPath={showAllProjects || showAllWorktrees}
+        onSelect={(id) => void handleSelect(id)}
+        onCancel={() => onDone(null)}
+        onToggleAllProjects={handleToggleAllProjects}
+        onToggleAllWorktrees={handleToggleAllWorktrees}
+        onRename={handleRename}
+      />
+    </Box>
+  );
+}
+
+/**
+ * Cross-project notice. `wave -r` auto-exits after a short delay (mirrors
+ * Claude Code's resume picker, which prints the cd command and exits); the
+ * in-TUI `/resume` picker waits for Esc instead, so the conversation behind it
+ * survives.
+ */
+function CrossProjectMessage({
+  command,
+  onExit,
+  autoExit,
+}: {
+  command: string;
+  onExit: () => void;
+  autoExit: boolean;
+}): React.ReactNode {
+  useEffect(() => {
+    if (!autoExit) return;
+    const timer = setTimeout(onExit, 100);
+    return () => clearTimeout(timer);
+  }, [autoExit, onExit]);
+
+  useInput((_input, key) => {
+    if (!autoExit && key.escape) {
+      onExit();
+    }
+  });
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      <Text>This conversation is from a different directory.</Text>
+      <Box flexDirection="column">
+        <Text>To resume, run:</Text>
+        <Text> {command}</Text>
+      </Box>
+      <Text dimColor>
+        {autoExit ? "(Command copied to clipboard)" : "Esc to go back"}
+      </Text>
+    </Box>
+  );
+}