wave-code 1.1.4 → 1.2.0

package/src/components/PlanView.tsx

@@ -0,0 +1,141 @@
+import React from "react";
+import { Box, Text, useInput, useWindowSize } from "ink";
+import { useLineScroll } from "../hooks/useLineScroll.js";
+
+// Row budget for the scroll indicators (↑ more / ↓ more, up to one each).
+const SCROLL_INDICATOR_BUDGET = 2;
+// Row budget for the fixed scroll-key hint shown when content is scrollable.
+const SCROLL_HINT_BUDGET = 1;
+// Overlay height as a fraction of the terminal height (spec: 50-60%).
+const PLAN_OVERLAY_HEIGHT_RATIO = 0.55;
+
+export interface PlanViewProps {
+  path?: string;
+  content?: string;
+  message?: string;
+  /** Available height (rows) for the whole overlay, computed by default from
+   *  the terminal size. Tests pass it explicitly for determinism. */
+  maxHeight?: number;
+  onCancel: () => void;
+}
+
+/**
+ * Overlay shown by the /plan command:
+ * - With `message` only: a plain status line (e.g. "Enabled plan mode").
+ * - With `path`/`content`: the current plan file contents as plain text lines
+ *   (no Markdown), fixed at ~55% of the terminal height with PgUp/PgDn and
+ *   Ctrl+u/Ctrl+d scrolling and ↑/↓ "N more" indicators.
+ * Esc dismisses the overlay.
+ */
+export const PlanView: React.FC<PlanViewProps> = ({
+  path,
+  content,
+  message,
+  maxHeight,
+  onCancel,
+}) => {
+  const { rows } = useWindowSize();
+  const overlayMaxHeight =
+    maxHeight ?? Math.max(Math.round(rows * PLAN_OVERLAY_HEIGHT_RATIO), 10);
+
+  const isMessageOnly = message !== undefined && content === undefined;
+
+  useInput((_input, key) => {
+    if (key.escape) {
+      onCancel();
+    }
+  });
+
+  // Hook order must be stable across renders, so compute the scroll state
+  // before the message-only early return.
+  const headerRows = 2 + (path ? 1 : 0); // "Current Plan" + path + footer hint
+  const visibleCount = Math.max(
+    1,
+    overlayMaxHeight -
+      headerRows -
+      SCROLL_INDICATOR_BUDGET -
+      SCROLL_HINT_BUDGET,
+  );
+  const planLines =
+    !isMessageOnly && content !== undefined && content !== ""
+      ? content.split("\n")
+      : [];
+  const { scrollOffset, hasMoreAbove, hasMoreBelow } = useLineScroll({
+    totalLines: planLines.length,
+    visibleCount,
+  });
+
+  if (isMessageOnly) {
+    return (
+      <Box
+        flexDirection="column"
+        paddingX={1}
+        borderStyle="single"
+        borderColor="cyan"
+        borderLeft={false}
+        borderRight={false}
+      >
+        <Text color="cyan">{message}</Text>
+        <Text dimColor>Press Escape to continue</Text>
+      </Box>
+    );
+  }
+
+  const visibleLines = planLines.slice(
+    scrollOffset,
+    scrollOffset + visibleCount,
+  );
+
+  return (
+    <Box
+      flexDirection="column"
+      paddingX={1}
+      borderStyle="single"
+      borderColor="cyan"
+      borderLeft={false}
+      borderRight={false}
+    >
+      <Text color="cyan" bold>
+        Current Plan
+      </Text>
+      {path ? (
+        <Text dimColor wrap="truncate-end">
+          {path}
+        </Text>
+      ) : null}
+      {hasMoreAbove && (
+        <Box>
+          <Text color="gray" dimColor>
+            ↑ {scrollOffset} more
+          </Text>
+        </Box>
+      )}
+      {visibleLines.length > 0 ? (
+        visibleLines.map((line, index) => (
+          <Box key={scrollOffset + index}>
+            <Text>{line || " "}</Text>
+          </Box>
+        ))
+      ) : (
+        <Text>No plan written yet.</Text>
+      )}
+      {hasMoreBelow && (
+        <Box>
+          <Text color="gray" dimColor>
+            ↓ {planLines.length - scrollOffset - visibleCount} more
+          </Text>
+        </Box>
+      )}
+      {(hasMoreAbove || hasMoreBelow) && (
+        <Box>
+          <Text color="gray" dimColor>
+            PgUp/PgDn page • Ctrl+u/d half page
+          </Text>
+        </Box>
+      )}
+      <Text dimColor>Press Escape to continue</Text>
+    </Box>
+  );
+};
+
+PlanView.displayName = "PlanView";

package/src/constants/commands.ts

@@ -25,6 +25,12 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "List available skills",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "hooks",
+    name: "hooks",
+    description: "View configured hooks",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "rewind",
     name: "rewind",
@@ -80,6 +86,12 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "View and manage workflow runs",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "plan",
+    name: "plan",
+    description: "Enable plan mode or view the current session plan",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "clear",
     name: "clear",

package/src/contexts/useChat.tsx

@@ -17,6 +17,7 @@ import type {
   SlashCommand,
   SubagentConfiguration,
   SkillMetadata,
+  HookEventConfig,
   PermissionDecision,
   PermissionMode,
   QueuedMessage,
@@ -34,10 +35,17 @@ import {
 import { logger } from "../utils/logger.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 import { expandLongTextPlaceholders } from "../managers/inputHandlers.js";
+import { readFile } from "node:fs/promises";
 
 import { BaseAppProps } from "../types.js";
 
 // Main Chat Context
+export interface PlanViewData {
+  path?: string;
+  content?: string;
+  message?: string;
+}
+
 export interface ChatContextType {
   messages: Message[];
   isLoading: boolean;
@@ -104,9 +112,17 @@ export interface ChatContextType {
   agentDefinitions: SubagentConfiguration[];
   // Skill metadata (for /skills overlay)
   skills: SkillMetadata[];
+  // Hook configs per scope (for /hooks overlay)
+  hooks: Partial<
+    Record<"user" | "project" | "plugin", Record<string, HookEventConfig[]>>
+  >;
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
+  // /plan overlay state + handler
+  planView: PlanViewData | null;
+  setPlanView: (view: PlanViewData | null) => void;
+  handlePlanCommand: (args?: string) => Promise<void>;
   // Permission confirmation state
   isConfirmationVisible: boolean;
   hasPendingConfirmations: boolean;
@@ -472,6 +488,12 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   >([]);
   // Skill metadata (for /skills overlay)
   const [skills, setSkills] = useState<SkillMetadata[]>([]);
+  // Hook configs per scope (for /hooks overlay)
+  const [hooks, setHooks] = useState<
+    Partial<
+      Record<"user" | "project" | "plugin", Record<string, HookEventConfig[]>>
+    >
+  >({});
 
   // Permission state
   const [permissionMode, setPermissionModeState] = useState<PermissionMode>(
@@ -479,6 +501,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       (bypassPermissions ? "bypassPermissions" : "default"),
   );
 
+  // Plan view state for the /plan command overlay
+  const [planView, setPlanView] = useState<PlanViewData | null>(null);
+
   // Confirmation state with queue-based architecture
   const [isConfirmationVisible, setIsConfirmationVisible] = useState(false);
   const [confirmingTool, setConfirmingTool] = useState<
@@ -540,7 +565,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // the incremental callbacks in initializeAgent below.
   const refreshMessages = useCallback(() => {
     if (!isExpandedRef.current && agentRef.current) {
-      const msgs = agentRef.current.messages.map(snapshotMessage);
+      // Pull the full UI display stream (keeps pre-compaction history);
+      // `agent.messages` would only expose the folded API context.
+      const msgs = agentRef.current.displayMessages.map(snapshotMessage);
       // Snapshot-safe: the full-list replacement makes the SDK state
       // authoritative. Any update still queued inside the 500ms throttle
       // window was applied to the SDK before this pull, so it is already
@@ -674,73 +701,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           // delayed by a streaming window).
           updateMessages.flush();
         },
-        onAddBangMessage: (command, messageId) => {
-          if (isExpandedRef.current) return;
-          updateMessages((prev) =>
-            prev.some((m) => m.id === messageId)
-              ? prev
-              : [
-                  ...prev,
-                  {
-                    id: messageId,
-                    role: "user",
-                    timestamp: new Date().toISOString(),
-                    blocks: [
-                      {
-                        type: "bang",
-                        command,
-                        output: "",
-                        stage: "running",
-                        exitCode: null,
-                      },
-                    ],
-                  },
-                ],
-          );
-          updateMessages.flush();
-        },
-        onUpdateBangMessage: (command, output, messageId) => {
-          if (isExpandedRef.current) return;
-          updateMessages((prev) =>
-            prev.map((m) =>
-              m.id === messageId
-                ? {
-                    ...m,
-                    blocks: m.blocks.map((b, idx) =>
-                      idx === m.blocks.length - 1 && b.type === "bang"
-                        ? { ...b, command, output }
-                        : b,
-                    ),
-                  }
-                : m,
-            ),
-          );
-        },
-        onCompleteBangMessage: (command, exitCode, messageId, output) => {
-          if (isExpandedRef.current) return;
-          updateMessages((prev) =>
-            prev.map((m) =>
-              m.id === messageId
-                ? {
-                    ...m,
-                    blocks: m.blocks.map((b, idx) =>
-                      idx === m.blocks.length - 1 && b.type === "bang"
-                        ? {
-                            ...b,
-                            command,
-                            exitCode,
-                            stage: "end",
-                            ...(output !== undefined ? { output } : {}),
-                          }
-                        : b,
-                    ),
-                  }
-                : m,
-            ),
-          );
-          // Completion signal — flush so the final state applies immediately.
-          updateMessages.flush();
-        },
         onLatestTotalTokensChange: (tokens) => {
           setLatestTotalTokens(tokens);
         },
@@ -865,9 +825,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         }
 
         // Get initial state — snapshot the SDK messages (never hold live
-        // references; see snapshotMessage)
+        // references; see snapshotMessage). Uses the full display stream so a
+        // restored session shows pre-compaction history too.
         setSessionId(agent.sessionId);
-        setMessages(agent.messages.map(snapshotMessage));
+        setMessages(agent.displayMessages.map(snapshotMessage));
         setIsLoading(agent.isLoading);
         setLatestTotalTokens(extractLatestTotalTokens(agent.messages));
         setIsCommandRunning(agent.isCommandRunning);
@@ -894,6 +855,19 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         // Get initial skill metadata
         const initialSkills = agent.getSkillMetadata?.() || [];
         setSkills(initialSkills);
+
+        // Get initial hooks (user/project from settings.json, plugin from
+        // the hook manager's plugin-registered set) — snapshot for /hooks.
+        const [userHooks, projectHooks, pluginHooks] = await Promise.all([
+          agent.getHooksByScope("user"),
+          agent.getHooksByScope("project"),
+          agent.getHooksByScope("plugin"),
+        ]);
+        setHooks({
+          user: userHooks,
+          project: projectHooks,
+          plugin: pluginHooks,
+        });
       } catch (error) {
         console.error("Failed to initialize AI manager:", error);
       }
@@ -1111,6 +1085,52 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     });
   }, []);
 
+  // /plan command handler:
+  // - Outside plan mode: switch to plan mode, wait for the plan file path
+  //   (generated asynchronously by PlanManager), then either send the given
+  //   description as a message (starting a plan query) or show a confirmation.
+  // - Inside plan mode: display the current plan file contents; `/plan open`
+  //   is not supported on any end (spec: plan-mode.md "三端均不支持").
+  const handlePlanCommand = useCallback(
+    async (args?: string) => {
+      const agent = agentRef.current;
+      const description = args?.trim() ?? "";
+      const argList = description.split(/\s+/).filter(Boolean);
+      const wantsOpen = argList[0] === "open";
+
+      if (permissionMode !== "plan") {
+        setPermissionMode("plan");
+        // Wait for the plan file path to be generated before triggering a
+        // query so the model always receives the plan file location (spec:
+        // plan-mode.md "路径生成必须先于查询触发").
+        const planPath = await agent?.awaitPlanFilePath();
+
+        if (description && !wantsOpen) {
+          await sendMessage(description);
+          return;
+        }
+        setPlanView({ message: "Enabled plan mode", path: planPath });
+        return;
+      }
+
+      // Already in plan mode — display the current plan file contents.
+      const planPath =
+        agent?.getPlanFilePath() ?? (await agent?.awaitPlanFilePath());
+      if (!planPath) {
+        setPlanView({ message: "No plan written yet." });
+        return;
+      }
+      try {
+        const content = await readFile(planPath, "utf8");
+        setPlanView({ path: planPath, content });
+      } catch (error) {
+        logger.warn("Failed to read plan file:", error);
+        setPlanView({ message: "No plan written yet." });
+      }
+    },
+    [permissionMode, sendMessage, setPermissionMode],
+  );
+
   // MCP management methods - delegate to Agent
   const connectMcpServer = useCallback(async (serverName: string) => {
     return (await agentRef.current?.connectMcpServer(serverName)) ?? false;
@@ -1311,8 +1331,12 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hasSlashCommand,
     agentDefinitions,
     skills,
+    hooks,
     permissionMode,
     setPermissionMode,
+    planView,
+    setPlanView,
+    handlePlanCommand,
     isConfirmationVisible,
     hasPendingConfirmations: confirmationQueue.length > 0,
     confirmingTool,