wave-code 1.2.0 → 1.3.0

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

package/src/constants/commands.ts

@@ -56,6 +56,12 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "View and manage plugins",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "reload-plugins",
+    name: "reload-plugins",
+    description: "Reload plugins in place, without restarting the session",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "btw",
     name: "btw",
@@ -92,6 +98,18 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "Enable plan mode or view the current session plan",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "resume",
+    name: "resume",
+    description: "Switch to another conversation without leaving the session",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
+  {
+    id: "rename",
+    name: "rename",
+    description: "Set a custom title for the current conversation",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "clear",
     name: "clear",

package/src/contexts/useChat.tsx

@@ -31,6 +31,8 @@ import {
   type WorktreeSession,
   OPERATION_CANCELLED_BY_USER,
   extractLatestTotalTokens,
+  PLUGIN_CHANGE_PENDING_MESSAGE,
+  PLUGIN_RELOADED_MESSAGE,
 } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
@@ -77,6 +79,17 @@ export interface ChatContextType {
   clearMessages: () => Promise<void>;
   compact: (instructions?: string) => Promise<void>;
   addDir: (args?: string) => Promise<void>;
+  /**
+   * Set the current session's custom title (`/rename <title>`). A blank title
+   * only prints the usage hint — no AI-generated titles (spec: session-management.md).
+   */
+  renameSession: (args?: string) => Promise<void>;
+  /**
+   * Switch to another conversation in-process (`/resume`). Pass `resumeWorkdir`
+   * when the target session lives in a sibling worktree of the same repo — the
+   * session then moves into that directory too.
+   */
+  resumeSession: (sessionId: string, resumeWorkdir?: string) => Promise<void>;
   abortMessage: () => void;
   recallQueuedMessage: () => QueuedMessage | null;
   removeQueuedMessageById: (id: string) => boolean;
@@ -131,6 +144,7 @@ export interface ChatContextType {
     input?: Record<string, unknown>;
     suggestedPrefix?: string;
     hidePersistentOption?: boolean;
+    outsideSafeZoneDirectory?: string;
     planContent?: string;
     permissionMode?: PermissionMode;
     warning?: string;
@@ -143,6 +157,7 @@ export interface ChatContextType {
     planContent?: string,
     permissionMode?: PermissionMode,
     warning?: string,
+    outsideSafeZoneDirectory?: string,
   ) => Promise<PermissionDecision>;
   hideConfirmation: () => void;
   handleConfirmationDecision: (decision: PermissionDecision) => void;
@@ -164,8 +179,10 @@ export interface ChatContextType {
   workingDirectory: string;
   version?: string;
   workdir?: string;
-  // Agent recreation (e.g. after plugin install)
-  recreateAgent: () => void;
+  // Plugin in-place reload (docs/specs/ecosystem/plugin.md「插件变更的就地重载」)
+  reloadPlugins: () => Promise<void>;
+  notifyPluginChange: () => void;
+  pluginHint: string | null;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -512,6 +529,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         input?: Record<string, unknown>;
         suggestedPrefix?: string;
         hidePersistentOption?: boolean;
+        outsideSafeZoneDirectory?: string;
         planContent?: string;
         permissionMode?: PermissionMode;
         warning?: string;
@@ -524,6 +542,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       toolInput?: Record<string, unknown>;
       suggestedPrefix?: string;
       hidePersistentOption?: boolean;
+      outsideSafeZoneDirectory?: string;
       planContent?: string;
       permissionMode?: PermissionMode;
       warning?: string;
@@ -536,6 +555,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     toolInput?: Record<string, unknown>;
     suggestedPrefix?: string;
     hidePersistentOption?: boolean;
+    outsideSafeZoneDirectory?: string;
     planContent?: string;
     permissionMode?: PermissionMode;
     warning?: string;
@@ -592,6 +612,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       planContent?: string,
       permissionMode?: PermissionMode,
       warning?: string,
+      outsideSafeZoneDirectory?: string,
     ): Promise<PermissionDecision> => {
       return new Promise<PermissionDecision>((resolve, reject) => {
         const queueItem = {
@@ -599,6 +620,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           toolInput,
           suggestedPrefix,
           hidePersistentOption,
+          outsideSafeZoneDirectory,
           planContent,
           permissionMode,
           warning,
@@ -775,6 +797,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               context.planContent,
               context.permissionMode,
               context.warning,
+              context.outsideSafeZoneDirectory,
             );
           } catch {
             // If confirmation was cancelled or failed, deny the operation
@@ -892,32 +915,50 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     ],
   );
 
-  // Recreate agent (e.g. after plugin install) — destroys current agent and reinitializes
-  const recreateAgent = useCallback(() => {
-    const currentSessionId = agentRef.current?.sessionId;
-    if (agentRef.current) {
-      try {
-        agentRef.current.destroy();
-      } catch {
-        // Ignore destroy errors
-      }
+  // 插件变更落盘后只置一个「待应用」信号并提示一次，不再重建 Agent；真正换装由
+  // 用户敲 /reload-plugins 触发，在当前会话内完成（docs/specs/ecosystem/plugin.md
+  // 「插件变更的就地重载」：会…不重建、不打断回合、不新建会话）。
+  const [pluginHint, setPluginHint] = useState<string | null>(null);
+  const pluginHintTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const showPluginHint = useCallback((message: string) => {
+    setPluginHint(message);
+    if (pluginHintTimer.current) {
+      clearTimeout(pluginHintTimer.current);
     }
-    agentRef.current = null;
-    setMessages([]);
-    setMcpServerStatuses([]);
-    setSlashCommands([]);
-    setAgentDefinitions([]);
-    setSkills([]);
-    setSessionId("");
-    setIsLoading(false);
-    setLatestTotalTokens(0);
-    setMaxInputTokens(200000);
-    setIsCommandRunning(false);
-    setIsCompacting(false);
-    if (currentSessionId) {
-      initializeAgent(currentSessionId);
+    // 一次性提示：数秒后自行消失，不留常驻标识（spec「插件变更提示」）。
+    pluginHintTimer.current = setTimeout(() => setPluginHint(null), 8000);
+  }, []);
+
+  const notifyPluginChange = useCallback(() => {
+    showPluginHint(PLUGIN_CHANGE_PENDING_MESSAGE);
+  }, [showPluginHint]);
+
+  const reloadPlugins = useCallback(async () => {
+    const agent = agentRef.current;
+    if (!agent) return;
+    try {
+      const result = await agent.reloadPlugins();
+      // 换装后本进程各会话的能力已变，UI 侧的命令 / 子代理 / 技能列表同步重读。
+      setSlashCommands(agent.getSlashCommands?.() || []);
+      setAgentDefinitions(agent.getSubagentConfigurations?.() || []);
+      setSkills(agent.getSkillMetadata?.() || []);
+      if (result.failures.length > 0) {
+        // 失败不回滚：如实提示，会话继续可用（spec 场景 11）。
+        showPluginHint(
+          `${PLUGIN_RELOADED_MESSAGE}部分插件加载失败：${result.failures
+            .map((failure) => `${failure.path}: ${failure.error}`)
+            .join("；")}`,
+        );
+      } else {
+        showPluginHint(PLUGIN_RELOADED_MESSAGE);
+      }
+    } catch (error) {
+      showPluginHint(
+        `插件重载失败：${error instanceof Error ? error.message : String(error)}`,
+      );
     }
-  }, [initializeAgent]);
+  }, [showPluginHint]);
 
   // Run initial agent creation
   useEffect(() => {
@@ -1061,6 +1102,90 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     );
   }, []);
 
+  // /rename: set the current conversation's custom title. The title is stored
+  // as a reserved `custom-title` entry appended to the session's own JSONL
+  // file, so `wave -r` and every GUI host read the same value. A blank title
+  // only prints the usage hint — no AI-generated titles (spec:
+  // session-management.md "不做 AI 自动标题").
+  const renameSession = useCallback(async (args?: string) => {
+    const agent = agentRef.current;
+    if (!agent) return;
+
+    const title = (args ?? "").trim();
+    const showResult = (content: string) => {
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+          role: "assistant",
+          timestamp: new Date().toISOString(),
+          blocks: [{ type: "text", content, stage: "end" }],
+        },
+      ]);
+    };
+
+    if (!title) {
+      showResult("Usage: /rename <title>");
+      return;
+    }
+
+    try {
+      await agent.renameSession(title);
+      showResult(`Conversation renamed to "${title}".`);
+    } catch (error) {
+      showResult(
+        `Failed to rename conversation: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }, []);
+
+  // /resume: switch to another conversation without leaving the process. The
+  // session id and its on-disk project directory move together, so the next
+  // message is appended to the target's own transcript. A failed restore leaves
+  // the current session untouched and only surfaces a notice.
+  const resumeSession = useCallback(
+    async (sessionId: string, resumeWorkdir?: string) => {
+      const agent = agentRef.current;
+      if (!agent) return;
+
+      try {
+        await agent.restoreSession(
+          sessionId,
+          resumeWorkdir ? { workdir: resumeWorkdir } : undefined,
+        );
+      } catch (error) {
+        // UI-only notice (same display path as /add-dir): nothing was switched,
+        // so nothing about the failed target is persisted.
+        setMessages((prev) => [
+          ...prev,
+          {
+            id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            role: "assistant",
+            timestamp: new Date().toISOString(),
+            blocks: [
+              {
+                type: "error",
+                content: `Failed to resume conversation: ${
+                  error instanceof Error ? error.message : String(error)
+                }`,
+              },
+            ],
+          },
+        ]);
+        return;
+      }
+
+      setSessionId(agent.sessionId);
+      setWorkingDirectory(agent.workingDirectory);
+      setIsLoading(agent.isLoading);
+      refreshMessages();
+      forceRemount();
+    },
+    [forceRemount, refreshMessages],
+  );
+
   // Unified interrupt method, interrupt both AI messages and command execution
   const abortMessage = useCallback(() => {
     agentRef.current?.abortMessage();
@@ -1170,6 +1295,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         input: next.toolInput,
         suggestedPrefix: next.suggestedPrefix,
         hidePersistentOption: next.hidePersistentOption,
+        outsideSafeZoneDirectory: next.outsideSafeZoneDirectory,
         planContent: next.planContent,
         permissionMode: next.permissionMode,
         warning: next.warning,
@@ -1257,7 +1383,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   const setModel = useCallback((model: string) => {
     if (agentRef.current) {
-      agentRef.current.setModel(model);
+      void agentRef.current.setModel(model);
       setCurrentModelState(model);
     }
   }, []);
@@ -1307,6 +1433,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     clearMessages,
     compact,
     addDir,
+    renameSession,
+    resumeSession,
     abortMessage,
     recallQueuedMessage,
     removeQueuedMessageById,
@@ -1355,7 +1483,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     workingDirectory,
     version,
     workdir,
-    recreateAgent,
+    reloadPlugins,
+    notifyPluginChange,
+    pluginHint,
   };
 
   return (