wave-code 1.1.4 → 1.2.0

package/src/hooks/useLineScroll.ts

@@ -0,0 +1,58 @@
+import { useState } from "react";
+import { useInput } from "ink";
+
+export interface UseLineScrollOptions {
+  /** Total number of content rows in the scrollable area. */
+  totalLines: number;
+  /** Number of rows visible at once (computed from the available height). */
+  visibleCount: number;
+}
+
+/**
+ * Fixed-height line scrolling shared by overlays whose content may exceed the
+ * terminal: keeps a scroll offset clamped to the visible window and handles
+ * PgUp/PgDn (full page) plus Ctrl+u/Ctrl+d (half page, aligned with Claude
+ * Code's modal pager keys). Returns the clamped offset and the ↑/↓ indicator
+ * flags so callers can render "N more" lines.
+ *
+ * Scroll position starts at the top on mount; callers that display a new
+ * content set remount this hook (e.g. an overlay component keyed by content),
+ * which resets the offset naturally.
+ */
+export function useLineScroll({
+  totalLines,
+  visibleCount,
+}: UseLineScrollOptions): {
+  scrollOffset: number;
+  hasMoreAbove: boolean;
+  hasMoreBelow: boolean;
+} {
+  const [scrollOffset, setScrollOffset] = useState(0);
+
+  const maxScroll = Math.max(0, totalLines - visibleCount);
+  const halfPage = Math.max(1, Math.ceil(visibleCount / 2));
+
+  useInput((input, key) => {
+    if (key.pageUp) {
+      setScrollOffset((offset) => Math.max(0, offset - visibleCount));
+    }
+    if (key.pageDown) {
+      setScrollOffset((offset) => Math.min(maxScroll, offset + visibleCount));
+    }
+    // Ctrl+u/Ctrl+d scroll half a page — fallback for keyboards without
+    // PgUp/PgDn (aligned with Claude Code's modal pager keys).
+    if (key.ctrl && input === "u") {
+      setScrollOffset((offset) => Math.max(0, offset - halfPage));
+    }
+    if (key.ctrl && input === "d") {
+      setScrollOffset((offset) => Math.min(maxScroll, offset + halfPage));
+    }
+  });
+
+  const clampedOffset = Math.min(scrollOffset, maxScroll);
+  return {
+    scrollOffset: clampedOffset,
+    hasMoreAbove: clampedOffset > 0,
+    hasMoreBelow: clampedOffset + visibleCount < totalLines,
+  };
+}

package/src/index.ts

@@ -188,7 +188,7 @@ export async function main() {
                 })
                 .option("scope", {
                   alias: "s",
-                  describe: "Scope to enable the plugin in",
+                  describe: "Scope to enable the plugin in (default: user)",
                   choices: ["user", "project", "local"],
                   type: "string",
                 });
@@ -251,10 +251,47 @@ export async function main() {
       })
       .command(
         "daemon",
-        "Manage the wave daemon (client subcommands — to START a daemon use `wave --daemon <socket>` instead)",
+        "Manage the wave daemon (client subcommands — daemons start on demand, or directly via `wave --daemon <socket>`)",
         (yargs) => {
           return yargs
             .help()
+            .command(
+              "create",
+              "Create a new session hosted by the daemon and print its sessionId",
+              (yargs) => {
+                return yargs
+                  .option("workdir", {
+                    describe:
+                      "Working directory for the new session (default: current directory)",
+                    type: "string",
+                  })
+                  .option("permission-mode", {
+                    describe:
+                      "Permission mode for the new session (default: bypassPermissions; options: default, bypassPermissions, acceptEdits, plan, dontAsk)",
+                    type: "string",
+                  })
+                  .option("model", {
+                    describe:
+                      "Model override for the new session (default: configured model)",
+                    type: "string",
+                  })
+                  .option("worktree", {
+                    describe:
+                      "Create the session in a new git worktree (name optional — auto-generated when omitted)",
+                    type: "string",
+                  });
+              },
+              async (argv) => {
+                const { daemonCreateCommand, DEFAULT_DAEMON_SOCKET } =
+                  await import("./daemon/commands.js");
+                await daemonCreateCommand(DEFAULT_DAEMON_SOCKET, {
+                  workdir: argv.workdir as string | undefined,
+                  permissionMode: argv.permissionMode as string | undefined,
+                  model: argv.model as string | undefined,
+                  worktree: argv.worktree as string | undefined,
+                });
+              },
+            )
             .command(
               "list",
               "List sessions hosted by the daemon (in-memory registry)",
@@ -292,7 +329,7 @@ export async function main() {
             )
             .command(
               "send <sessionId> <message>",
-              "Inject a message into a session and wait for the reply",
+              "Inject a message into a session (async by default; --wait N to get the reply)",
               (yargs) => {
                 return yargs
                   .positional("sessionId", {
@@ -303,9 +340,10 @@ export async function main() {
                     describe: "Message to send",
                     type: "string",
                   })
-                  .option("timeout", {
-                    describe: "Seconds to wait for the reply (0 = no limit)",
-                    default: 600,
+                  .option("wait", {
+                    describe:
+                      "Seconds to wait for the reply and print it (0 = fire-and-forget, the default)",
+                    default: 0,
                     type: "number",
                   });
               },
@@ -316,7 +354,7 @@ export async function main() {
                   DEFAULT_DAEMON_SOCKET,
                   argv.sessionId as string,
                   argv.message as string,
-                  { timeout: argv.timeout as number },
+                  { wait: argv.wait as number },
                 );
               },
             )
@@ -346,7 +384,8 @@ export async function main() {
                     type: "string",
                   })
                   .option("answer", {
-                    describe: "Answers JSON for AskUserQuestion requests",
+                    describe:
+                      'AskUserQuestion answers: JSON object of {question: answer} or option numbers per question (e.g. "0" or "1,0")',
                     type: "string",
                   })
                   .option("rule", {
@@ -394,6 +433,53 @@ export async function main() {
                 );
               },
             )
+            .command(
+              "destroy <sessionId>",
+              "Destroy a daemon session (idempotent)",
+              (yargs) => {
+                return yargs
+                  .positional("sessionId", {
+                    describe: "Session ID of the session to destroy",
+                    type: "string",
+                  })
+                  .option("remove-worktree", {
+                    describe:
+                      "Also remove the session's git worktree (resolved via git, removed via protocol removeWorktree) before destroying",
+                    type: "boolean",
+                  });
+              },
+              async (argv) => {
+                const { daemonDestroyCommand, DEFAULT_DAEMON_SOCKET } =
+                  await import("./daemon/commands.js");
+                await daemonDestroyCommand(
+                  DEFAULT_DAEMON_SOCKET,
+                  argv.sessionId as string,
+                  {
+                    removeWorktree: argv.removeWorktree as boolean | undefined,
+                  },
+                );
+              },
+            )
+            .command(
+              "stop",
+              "Gracefully stop the daemon (idempotent — no-op when it is not running)",
+              {},
+              async () => {
+                const { daemonStopCommand, DEFAULT_DAEMON_SOCKET } =
+                  await import("./daemon/commands.js");
+                await daemonStopCommand(DEFAULT_DAEMON_SOCKET);
+              },
+            )
+            .command(
+              "restart",
+              "Restart the daemon (graceful stop + relaunch; starts one when not running)",
+              {},
+              async () => {
+                const { daemonRestartCommand, DEFAULT_DAEMON_SOCKET } =
+                  await import("./daemon/commands.js");
+                await daemonRestartCommand(DEFAULT_DAEMON_SOCKET);
+              },
+            )
             .demandCommand(1, "Please specify a daemon subcommand");
         },
       )

package/src/managers/inputHandlers.ts

@@ -372,6 +372,8 @@ export const handleCommandSelect = (
           dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
         } else if (command === "skills") {
           dispatch({ type: "SET_SHOW_SKILLS_MANAGER", payload: true });
+        } else if (command === "hooks") {
+          dispatch({ type: "SET_SHOW_HOOKS_MANAGER", payload: true });
         } else if (command === "rewind") {
           dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
         } else if (command === "help") {

package/src/managers/inputReducer.ts

@@ -109,6 +109,7 @@ export interface InputManagerCallbacks {
   onClearMessages?: () => Promise<void>;
   onCompact?: (instructions?: string) => Promise<void>;
   onAddDir?: (args?: string) => Promise<void>;
+  onPlanCommand?: (args?: string) => Promise<void> | void;
   sessionId?: string;
   workdir?: string;
   getFullMessageThread?: () => Promise<{
@@ -148,6 +149,7 @@ export interface InputState {
   showModelSelector: boolean;
   showWorkflowManager: boolean;
   showSkillsManager: boolean;
+  showHooksManager: boolean;
   permissionMode: PermissionMode;
   selectorJustUsed: boolean;
   history: PromptEntry[];
@@ -187,6 +189,7 @@ export const initialState: InputState = {
   showModelSelector: false,
   showWorkflowManager: false,
   showSkillsManager: false,
+  showHooksManager: false,
   permissionMode: "default",
   selectorJustUsed: false,
   history: [],
@@ -469,6 +472,7 @@ export type InputAction =
   | { type: "SET_SHOW_MODEL_SELECTOR"; payload: boolean }
   | { type: "SET_SHOW_WORKFLOW_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_SKILLS_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_HOOKS_MANAGER"; payload: boolean }
   | { type: "SET_PERMISSION_MODE"; payload: PermissionMode }
   | { type: "SET_SELECTOR_JUST_USED"; payload: boolean }
   | { type: "INSERT_TEXT_WITH_PLACEHOLDER"; payload: string }
@@ -705,6 +709,12 @@ export function inputReducer(
         showSkillsManager: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_HOOKS_MANAGER":
+      return {
+        ...state,
+        showHooksManager: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_PERMISSION_MODE":
       return { ...state, permissionMode: action.payload };
     case "SET_SELECTOR_JUST_USED":

package/src/reducers/hooksManagerReducer.ts

@@ -0,0 +1,92 @@
+import { Key } from "ink";
+
+export type PendingEffect = { type: "CANCEL" };
+
+export interface HooksManagerState {
+  selectedIndex: number;
+  viewMode: "list" | "detail";
+  pendingEffect: PendingEffect | null;
+}
+
+export type HooksManagerAction =
+  | { type: "MOVE_UP" }
+  | { type: "MOVE_DOWN"; itemCount: number }
+  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      itemCount: number;
+    }
+  | { type: "CLEAR_PENDING_EFFECT" };
+
+export function hooksManagerReducer(
+  state: HooksManagerState,
+  action: HooksManagerAction,
+): HooksManagerState {
+  switch (action.type) {
+    case "MOVE_UP":
+      return {
+        ...state,
+        selectedIndex: Math.max(0, state.selectedIndex - 1),
+      };
+    case "MOVE_DOWN":
+      return {
+        ...state,
+        selectedIndex: Math.min(
+          Math.max(0, action.itemCount - 1),
+          state.selectedIndex + 1,
+        ),
+      };
+    case "SET_VIEW_MODE":
+      return { ...state, viewMode: action.viewMode };
+    case "HANDLE_KEY": {
+      const { key, itemCount } = action;
+
+      if (key.return) {
+        if (state.viewMode === "list") {
+          return { ...state, viewMode: "detail" };
+        }
+        // Aligned with AgentsManager/SkillsManager detail view: Enter
+        // returns to the list.
+        return { ...state, viewMode: "list" };
+      }
+
+      if (key.escape) {
+        if (state.viewMode === "detail") {
+          return { ...state, viewMode: "list" };
+        }
+        return { ...state, pendingEffect: { type: "CANCEL" } };
+      }
+
+      // Detail view does not respond to arrow keys (aligned with
+      // AgentsManager/SkillsManager).
+      if (state.viewMode === "detail") {
+        return state;
+      }
+
+      if (key.upArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.max(0, state.selectedIndex - 1),
+        };
+      }
+
+      if (key.downArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.min(
+            Math.max(0, itemCount - 1),
+            state.selectedIndex + 1,
+          ),
+        };
+      }
+
+      return state;
+    }
+    case "CLEAR_PENDING_EFFECT":
+      return { ...state, pendingEffect: null };
+    default:
+      return state;
+  }
+}