wave-code 1.2.0 → 1.3.0

package/src/components/PlanView.tsx

@@ -1,6 +1,7 @@
-import React from "react";
+import React, { useState } from "react";
 import { Box, Text, useInput, useWindowSize } from "ink";
 import { useLineScroll } from "../hooks/useLineScroll.js";
+import { ScrolledContent } from "./ScrolledContent.js";
 
 // Row budget for the scroll indicators (↑ more / ↓ more, up to one each).
 const SCROLL_INDICATOR_BUDGET = 2;
@@ -60,8 +61,11 @@ export const PlanView: React.FC<PlanViewProps> = ({
     !isMessageOnly && content !== undefined && content !== ""
       ? content.split("\n")
       : [];
+  // Rows really occupied by the plan (wrapped rows included), measured after
+  // layout by <ScrolledContent>.
+  const [contentRows, setContentRows] = useState(0);
   const { scrollOffset, hasMoreAbove, hasMoreBelow } = useLineScroll({
-    totalLines: planLines.length,
+    totalLines: contentRows,
     visibleCount,
   });
 
@@ -81,11 +85,6 @@ export const PlanView: React.FC<PlanViewProps> = ({
     );
   }
 
-  const visibleLines = planLines.slice(
-    scrollOffset,
-    scrollOffset + visibleCount,
-  );
-
   return (
     <Box
       flexDirection="column"
@@ -110,19 +109,25 @@ export const PlanView: React.FC<PlanViewProps> = ({
           </Text>
         </Box>
       )}
-      {visibleLines.length > 0 ? (
-        visibleLines.map((line, index) => (
-          <Box key={scrollOffset + index}>
-            <Text>{line || " "}</Text>
-          </Box>
-        ))
-      ) : (
-        <Text>No plan written yet.</Text>
-      )}
+      <ScrolledContent
+        visibleRows={visibleCount}
+        scrollOffset={scrollOffset}
+        onMeasuredRows={setContentRows}
+      >
+        {planLines.length > 0 ? (
+          planLines.map((line, index) => (
+            <Box key={index}>
+              <Text>{line || " "}</Text>
+            </Box>
+          ))
+        ) : (
+          <Text>No plan written yet.</Text>
+        )}
+      </ScrolledContent>
       {hasMoreBelow && (
         <Box>
           <Text color="gray" dimColor>
-            ↓ {planLines.length - scrollOffset - visibleCount} more
+            ↓ {contentRows - scrollOffset - visibleCount} more
           </Text>
         </Box>
       )}

package/src/components/PluginManagerShell.tsx

@@ -13,9 +13,9 @@ import { PluginManagerContext } from "../contexts/PluginManagerContext.js";
 export const PluginManagerShell: React.FC<{
   children?: React.ReactNode;
   onCancel?: () => void;
-  onPluginInstalled?: () => void;
-}> = ({ children, onCancel, onPluginInstalled }) => {
-  const pluginManager = usePluginManager({ onPluginInstalled });
+  onPluginChanged?: () => void;
+}> = ({ children, onCancel, onPluginChanged }) => {
+  const pluginManager = usePluginManager({ onPluginChanged });
   const { state, actions, discoverablePlugins } = pluginManager;
 
   const setView = (view: ViewType) => {

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>
   );