wave-code 1.2.0 → 1.3.0

package/src/reducers/confirmationReducer.ts

@@ -2,12 +2,14 @@ import { Key } from "ink";
 import type { PermissionDecision, PermissionMode } from "wave-agent-sdk";
 import {
   BASH_TOOL_NAME,
+  EDIT_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,
   ENTER_PLAN_MODE_TOOL_NAME,
+  WRITE_TOOL_NAME,
 } from "wave-agent-sdk";
 
 export interface ConfirmationState {
-  selectedOption: "auto" | "bypass" | "allow" | "alternative";
+  selectedOption: "auto" | "bypass" | "allow" | "addDirectory" | "alternative";
   alternativeText: string;
   alternativeCursorPosition: number;
   hasUserInput: boolean;
@@ -30,6 +32,7 @@ export type ConfirmationAction =
       toolInput?: Record<string, unknown>;
       suggestedPrefix?: string;
       hidePersistentOption?: boolean;
+      outsideSafeZoneDirectory?: string;
       permissionMode?: PermissionMode;
     };
 
@@ -96,6 +99,7 @@ export function confirmationReducer(
         toolInput,
         suggestedPrefix,
         hidePersistentOption,
+        outsideSafeZoneDirectory,
         permissionMode,
       } = action;
 
@@ -135,6 +139,16 @@ export function confirmationReducer(
             behavior: "allow",
             newPermissionMode: "bypassPermissions",
           };
+        } else if (
+          state.selectedOption === "addDirectory" &&
+          outsideSafeZoneDirectory
+        ) {
+          // Approve this operation AND add the out-of-Safe-Zone target
+          // directory to this session's Safe Zone (in-memory only).
+          decision = {
+            behavior: "allow",
+            newAdditionalDirectory: outsideSafeZoneDirectory,
+          };
         } else if (state.alternativeText.trim()) {
           decision = {
             behavior: "deny",
@@ -176,6 +190,11 @@ export function confirmationReducer(
 
       const availableOptions: ConfirmationState["selectedOption"][] = [];
       availableOptions.push("allow");
+      if (
+        (toolName === EDIT_TOOL_NAME || toolName === WRITE_TOOL_NAME) &&
+        outsideSafeZoneDirectory
+      )
+        availableOptions.push("addDirectory");
       if (!hidePersistentOption) availableOptions.push("auto");
       if (
         toolName === EXIT_PLAN_MODE_TOOL_NAME ||

package/src/reducers/selectorReducer.ts

@@ -15,6 +15,7 @@ export type SelectorAction<T = unknown> =
   | { type: "MOVE_DOWN" }
   | { type: "RESET_INDEX" }
   | { type: "SET_ITEMS"; items: T[] }
+  | { type: "SET_INDEX"; index: number }
   | { type: "HANDLE_KEY"; key: Key; hasInsert: boolean }
   | { type: "TOGGLE_ALL_PROJECTS" }
   | { type: "TOGGLE_ALL_WORKTREES" }
@@ -39,6 +40,8 @@ export function selectorReducer<T = unknown>(
       return { ...state, selectedIndex: 0 };
     case "SET_ITEMS":
       return { ...state, items: action.items, selectedIndex: 0 };
+    case "SET_INDEX":
+      return { ...state, selectedIndex: action.index };
     case "TOGGLE_ALL_PROJECTS":
       return { ...state, showAllProjects: !state.showAllProjects };
     case "TOGGLE_ALL_WORKTREES":

package/src/session-selector-cli.tsx

@@ -1,263 +1,17 @@
-import React, { useState, useCallback, useEffect, useRef } from "react";
-import { render, Box, Text } from "ink";
-import { existsSync } from "fs";
+import React from "react";
+import { render } from "ink";
 import {
-  PathEncoder,
-  listSessions,
-  listAllSessions,
-  truncateContent,
-  type SessionMetadata,
-} from "wave-agent-sdk";
-import { SessionSelector } from "./components/SessionSelector.js";
-import { setClipboardText } from "./utils/clipboard.js";
+  SessionSelectorFlow,
+  type SessionSelectorResult,
+} from "./components/SessionSelectorFlow.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 };
-
-/** POSIX single-quote wrapping for use inside a `cd <path> && ...` command. */
-function quotePath(p: string): string {
-  return `'${p.replace(/'/g, `'\\''`)}'`;
-}
-
-export type SessionOwnership =
-  | { kind: "current" }
-  | { kind: "worktree"; resumeWorkdir: string }
-  | { kind: "cross-project"; command: string };
-
-/**
- * Decide how a selected session relates to the current working directory.
- *
- * Ownership is decided by comparing encoded directory names — the decoded
- * workdir is lossy for paths containing "-", but re-encoding it reproduces the
- * original encoded directory name exactly.
- *
- * - current:      session belongs to the current directory → resume in place
- * - worktree:     session belongs to a sibling same-repo worktree → resume
- *                 after chdir into it (skipped when the worktree dir is gone)
- * - cross-project: session belongs to another project → print a cd command
- */
-export async function resolveSessionOwnership(
-  session: { id: string; workdir: string },
-  opts: { worktreePaths: string[]; currentWorkdir: string },
-): Promise<SessionOwnership> {
-  const encoder = new PathEncoder();
-  // encode() resolves the path via realpath and throws ENOENT when the
-  // directory no longer exists (e.g. a deleted worktree); fall back to the
-  // pure string encodeSync so the picker still works for ghost sessions.
-  let sessionEncoded: string;
-  try {
-    sessionEncoded = await encoder.encode(session.workdir);
-  } catch {
-    sessionEncoded = encoder.encodeSync(session.workdir);
-  }
-  const cwdEncoded = await encoder.encode(opts.currentWorkdir);
-
-  if (sessionEncoded === cwdEncoded) {
-    return { kind: "current" };
-  }
-
-  for (const wt of opts.worktreePaths) {
-    let wtEncoded: string;
-    try {
-      wtEncoded = await encoder.encode(wt);
-    } catch {
-      wtEncoded = encoder.encodeSync(wt);
-    }
-    if (wtEncoded === sessionEncoded && existsSync(wt)) {
-      return { kind: "worktree", resumeWorkdir: wt };
-    }
-  }
-
-  return {
-    kind: "cross-project",
-    command: `cd ${quotePath(session.workdir)} && wave --restore ${session.id}`,
-  };
-}
-
-/**
- * Interactive session picker for `wave -r` (restore without an ID).
- *
- * 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 exit
- */
-function SessionSelectorFlow({
-  currentWorkdir,
-  worktreePaths,
-  onDone,
-}: {
-  currentWorkdir: string;
-  worktreePaths: string[];
-  onDone: (result: SessionSelectorResult | null) => void;
-}): 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],
-  );
-
-  if (crossProjectCommand) {
-    return (
-      <CrossProjectMessage
-        command={crossProjectCommand}
-        onExit={() => onDone(null)}
-      />
-    );
-  }
-
-  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}
-      />
-    </Box>
-  );
-}
+export type { SessionSelectorResult };
 
 /**
- * Cross-project message auto-exits after a short delay (mirrors Claude Code's
- * resume picker, which prints the cd command and exits).
+ * Interactive session picker for `wave -r` (restore without an ID), rendered in
+ * its own Ink instance before the main TUI starts. The picker itself is shared
+ * with the in-TUI `/resume` command (see `SessionSelectorFlow`).
  */
-function CrossProjectMessage({
-  command,
-  onExit,
-}: {
-  command: string;
-  onExit: () => void;
-}): React.ReactNode {
-  useEffect(() => {
-    const timer = setTimeout(onExit, 100);
-    return () => clearTimeout(timer);
-  }, [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>(Command copied to clipboard)</Text>
-    </Box>
-  );
-}
-
 export async function startSessionSelectorCli({
   workdir,
   worktreePaths = [],