wave-code 0.0.2

package/src/hooks/useInputState.ts

@@ -0,0 +1,66 @@
+import { useState, useCallback } from "react";
+
+export const useInputState = () => {
+  const [inputText, setInputText] = useState("");
+  const [cursorPosition, setCursorPosition] = useState(0);
+
+  const insertTextAtCursor = useCallback((text: string) => {
+    setCursorPosition((currentCursor) => {
+      setInputText((currentText) => {
+        const beforeCursor = currentText.substring(0, currentCursor);
+        const afterCursor = currentText.substring(currentCursor);
+        return beforeCursor + text + afterCursor;
+      });
+      return currentCursor + text.length;
+    });
+  }, []);
+
+  const deleteCharAtCursor = useCallback(() => {
+    setCursorPosition((currentCursor) => {
+      if (currentCursor > 0) {
+        setInputText((currentText) => {
+          const beforeCursor = currentText.substring(0, currentCursor - 1);
+          const afterCursor = currentText.substring(currentCursor);
+          return beforeCursor + afterCursor;
+        });
+        return currentCursor - 1;
+      }
+      return currentCursor;
+    });
+  }, []);
+
+  const clearInput = useCallback(() => {
+    setInputText("");
+    setCursorPosition(0);
+  }, []);
+
+  const moveCursorLeft = useCallback(() => {
+    setCursorPosition((current) => Math.max(0, current - 1));
+  }, []);
+
+  const moveCursorRight = useCallback(() => {
+    setCursorPosition((current) => Math.min(inputText.length, current + 1));
+  }, [inputText.length]);
+
+  const moveCursorToStart = useCallback(() => {
+    setCursorPosition(0);
+  }, []);
+
+  const moveCursorToEnd = useCallback(() => {
+    setCursorPosition(inputText.length);
+  }, [inputText.length]);
+
+  return {
+    inputText,
+    setInputText,
+    cursorPosition,
+    setCursorPosition,
+    insertTextAtCursor,
+    deleteCharAtCursor,
+    clearInput,
+    moveCursorLeft,
+    moveCursorRight,
+    moveCursorToStart,
+    moveCursorToEnd,
+  };
+};

package/src/hooks/useMemoryTypeSelector.ts

@@ -0,0 +1,40 @@
+import { useState } from "react";
+
+export interface UseMemoryTypeSelectorReturn {
+  showMemoryTypeSelector: boolean;
+  memoryMessage: string;
+  activateMemoryTypeSelector: (message: string) => void;
+  handleMemoryTypeSelect: (type: "project" | "user") => void;
+  handleCancelMemoryTypeSelect: () => void;
+}
+
+export const useMemoryTypeSelector = (): UseMemoryTypeSelectorReturn => {
+  const [showMemoryTypeSelector, setShowMemoryTypeSelector] = useState(false);
+  const [memoryMessage, setMemoryMessage] = useState("");
+
+  const activateMemoryTypeSelector = (message: string) => {
+    setMemoryMessage(message);
+    setShowMemoryTypeSelector(true);
+  };
+
+  const handleMemoryTypeSelect = (type: "project" | "user"): void => {
+    setShowMemoryTypeSelector(false);
+    setMemoryMessage("");
+    // Type parameter is passed by external component, here only responsible for closing selector
+    // Actual type handling is completed in useInputKeyboardHandler
+    void type; // Explicitly mark parameter as known but unused
+  };
+
+  const handleCancelMemoryTypeSelect = () => {
+    setShowMemoryTypeSelector(false);
+    setMemoryMessage("");
+  };
+
+  return {
+    showMemoryTypeSelector,
+    memoryMessage,
+    activateMemoryTypeSelector,
+    handleMemoryTypeSelect,
+    handleCancelMemoryTypeSelect,
+  };
+};

package/src/hooks/usePagination.ts

@@ -0,0 +1,203 @@
+import { useState, useEffect, useMemo } from "react";
+import { useInput } from "ink";
+import type { Message } from "wave-agent-sdk";
+import { MESSAGES_PER_PAGE } from "../utils/constants.js";
+
+interface PaginationInfo {
+  currentPage: number;
+  totalPages: number;
+  startIndex: number;
+  endIndex: number;
+  messagesPerPage: number;
+}
+
+export const usePagination = (messages: Message[]) => {
+  const messagesPerPage = MESSAGES_PER_PAGE;
+
+  // Calculate pagination info, ensuring first page can be incomplete while subsequent pages are complete
+  const paginationInfo = useMemo((): PaginationInfo => {
+    if (messages.length <= messagesPerPage) {
+      // If total messages don't exceed one page, display all messages directly
+      return {
+        currentPage: 1,
+        totalPages: 1,
+        startIndex: 0,
+        endIndex: messages.length,
+        messagesPerPage,
+      };
+    }
+
+    // Calculate remaining messages (messages other than the first page)
+    const remainingMessages = messages.length % messagesPerPage;
+
+    if (remainingMessages === 0) {
+      // Message count fits perfectly into complete pages, use standard pagination
+      const totalPages = Math.ceil(messages.length / messagesPerPage);
+      const currentPage = totalPages;
+      const startIndex = (currentPage - 1) * messagesPerPage;
+      const endIndex = messages.length;
+
+      return {
+        currentPage,
+        totalPages,
+        startIndex,
+        endIndex,
+        messagesPerPage,
+      };
+    } else {
+      // Has remaining messages, let first page display remaining messages, subsequent pages are complete
+      const firstPageMessageCount = remainingMessages;
+      const totalPages = Math.floor(messages.length / messagesPerPage) + 1;
+
+      // Default to showing the last page (complete page)
+      const currentPage = totalPages;
+      const startIndex =
+        firstPageMessageCount + (currentPage - 2) * messagesPerPage;
+      const endIndex = messages.length;
+
+      return {
+        currentPage,
+        totalPages,
+        startIndex,
+        endIndex,
+        messagesPerPage,
+      };
+    }
+  }, [messages.length, messagesPerPage]);
+
+  // Manually controlled current page (for keyboard navigation)
+  const [manualPage, setManualPage] = useState<number | null>(null);
+
+  // Calculate actual display page info
+  const displayInfo = useMemo((): PaginationInfo => {
+    if (manualPage === null) {
+      return paginationInfo; // Auto mode: display last page
+    }
+
+    // Manual mode: display user-selected page
+    const totalPages = paginationInfo.totalPages;
+    const currentPage = Math.min(Math.max(1, manualPage), totalPages);
+
+    if (messages.length <= messagesPerPage) {
+      // Only one page case
+      return {
+        currentPage,
+        totalPages,
+        startIndex: 0,
+        endIndex: messages.length,
+        messagesPerPage,
+      };
+    }
+
+    const remainingMessages = messages.length % messagesPerPage;
+
+    if (remainingMessages === 0) {
+      // Message count fits perfectly into complete pages
+      const startIndex = (currentPage - 1) * messagesPerPage;
+      const endIndex = Math.min(startIndex + messagesPerPage, messages.length);
+
+      return {
+        currentPage,
+        totalPages,
+        startIndex,
+        endIndex,
+        messagesPerPage,
+      };
+    } else {
+      // First page incomplete, subsequent pages complete
+      if (currentPage === 1) {
+        // First page: display remaining message count
+        return {
+          currentPage,
+          totalPages,
+          startIndex: 0,
+          endIndex: remainingMessages,
+          messagesPerPage,
+        };
+      } else {
+        // Other pages: display complete message count per page
+        const firstPageMessageCount = remainingMessages;
+        const startIndex =
+          firstPageMessageCount + (currentPage - 2) * messagesPerPage;
+        const endIndex = Math.min(
+          startIndex + messagesPerPage,
+          messages.length,
+        );
+
+        return {
+          currentPage,
+          totalPages,
+          startIndex,
+          endIndex,
+          messagesPerPage,
+        };
+      }
+    }
+  }, [messages.length, messagesPerPage, manualPage, paginationInfo]);
+
+  // When message count changes, if user hasn't manually navigated, reset to auto mode
+  useEffect(() => {
+    if (manualPage !== null) {
+      // If user is currently on the last page, keep auto mode
+      const totalPages = Math.ceil(messages.length / messagesPerPage);
+      if (manualPage >= totalPages) {
+        setManualPage(null);
+      }
+    }
+  }, [messages.length, messagesPerPage, manualPage]);
+
+  // Pagination functionality
+  const goToPage = (page: number | null) => {
+    setManualPage(page);
+  };
+
+  const goToPrevPage = () => {
+    const currentPage = manualPage ?? displayInfo.currentPage;
+    setManualPage(Math.max(1, currentPage - 1));
+  };
+
+  const goToNextPage = () => {
+    const currentPage = manualPage ?? displayInfo.currentPage;
+    setManualPage(Math.min(displayInfo.totalPages, currentPage + 1));
+  };
+
+  const goToFirstPage = () => {
+    setManualPage(1);
+  };
+
+  const goToLastPage = () => {
+    setManualPage(null); // Return to auto mode (last page)
+  };
+
+  // Integrate keyboard shortcut handling
+  useInput((input, key) => {
+    // Ctrl+U/D shortcuts (Vim/Less style)
+    if (key.ctrl) {
+      if (input === "u") {
+        goToPrevPage();
+      } else if (input === "d") {
+        goToNextPage();
+      }
+    }
+
+    // Page Up/Down support
+    if (key.pageUp) {
+      goToPrevPage();
+    }
+
+    if (key.pageDown) {
+      goToNextPage();
+    }
+  });
+
+  return {
+    displayInfo,
+    manualPage,
+    setManualPage,
+    goToPage,
+    goToPrevPage,
+    goToNextPage,
+    goToFirstPage,
+    goToLastPage,
+  };
+};

package/src/index.ts

@@ -0,0 +1,108 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { startCli } from "./cli.js";
+import { listSessions } from "wave-agent-sdk";
+
+// Export main function for external use
+export async function main() {
+  const argv = await yargs(hideBin(process.argv))
+    .option("restore", {
+      alias: "r",
+      description: "Restore session by ID",
+      type: "string",
+    })
+    .option("continue", {
+      alias: "c",
+      description: "Continue from last session",
+      type: "boolean",
+    })
+    .option("plain", {
+      alias: "p",
+      description: "Plain mode with message to send",
+      type: "string",
+    })
+    .option("list-sessions", {
+      description: "List all available sessions",
+      type: "boolean",
+    })
+    .version()
+    .alias("v", "version")
+    .example("$0", "Start CLI with default settings")
+    .example("$0 --restore session_123", "Restore specific session")
+    .example("$0 --continue", "Continue from last session")
+    .example("$0 --plain 'Hello'", "Send message in plain mode")
+    .example("$0 -p 'Hello'", "Send message in plain mode (short)")
+    .example("$0 --list-sessions", "List all available sessions")
+    .help("h")
+    .parseAsync();
+
+  // Handle list sessions command
+  if (argv.listSessions) {
+    try {
+      const currentWorkdir = process.cwd();
+      const sessions = await listSessions(currentWorkdir);
+
+      if (sessions.length === 0) {
+        console.log(`No sessions found for workdir: ${currentWorkdir}`);
+        return;
+      }
+
+      console.log(`Available sessions for: ${currentWorkdir}`);
+      console.log("==========================================");
+
+      for (const session of sessions) {
+        const startedAt = new Date(session.startedAt).toLocaleString();
+        const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
+
+        console.log(`ID: ${session.id}`);
+        console.log(`  Workdir: ${session.workdir}`);
+        console.log(`  Started: ${startedAt}`);
+        console.log(`  Last Active: ${lastActiveAt}`);
+        console.log(`  Last Message Tokens: ${session.latestTotalTokens}`);
+        console.log("");
+      }
+
+      return;
+    } catch (error) {
+      console.error("Failed to list sessions:", error);
+      process.exit(1);
+    }
+  }
+
+  // Handle plain mode directly
+  if (argv.plain !== undefined) {
+    const { startPlainCli } = await import("./plain-cli.js");
+    return startPlainCli({
+      restoreSessionId: argv.restore,
+      continueLastSession: argv.continue,
+      message: argv.plain,
+    });
+  }
+
+  await startCli({
+    restoreSessionId: argv.restore,
+    continueLastSession: argv.continue,
+  });
+}
+
+// Export CLI function
+export { startCli } from "./cli.js";
+
+// Export logger
+export { logger } from "./utils/logger.js";
+
+// Export clipboard utilities
+export {
+  readClipboardImage,
+  cleanupTempImage,
+  hasClipboardImage,
+  type ClipboardImageResult,
+} from "./utils/clipboard.js";
+
+// Execute main function if this file is run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("Failed to start WAVE Code:", error);
+    process.exit(1);
+  });
+}

package/src/plain-cli.ts

@@ -0,0 +1,66 @@
+import { Agent, AgentCallbacks } from "wave-agent-sdk";
+import { logger } from "./utils/logger.js";
+
+export interface PlainCliOptions {
+  restoreSessionId?: string;
+  continueLastSession?: boolean;
+  message?: string;
+}
+
+export async function startPlainCli(options: PlainCliOptions): Promise<void> {
+  const { restoreSessionId, continueLastSession, message } = options;
+
+  if (
+    (!message || message.trim() === "") &&
+    !continueLastSession &&
+    !restoreSessionId
+  ) {
+    console.error(
+      "Plain mode requires a message: use --plain 'your message' or -p 'your message'",
+    );
+    process.exit(1);
+  }
+
+  let agent: Agent;
+  let lastAssistantMessage: string | undefined;
+
+  // Setup callbacks for agent
+  const callbacks: AgentCallbacks = {
+    onAssistantMessageAdded: (content?: string) => {
+      // Store the content instead of immediately printing it
+      if (content) {
+        lastAssistantMessage = content;
+      }
+    },
+  };
+
+  try {
+    // Initialize agent
+    agent = await Agent.create({
+      callbacks,
+      restoreSessionId,
+      continueLastSession,
+      logger,
+    });
+
+    // Send message if provided and not empty
+    if (message && message.trim() !== "") {
+      await agent.sendMessage(message);
+    }
+
+    // Output only the last assistant message
+    if (lastAssistantMessage) {
+      console.log(lastAssistantMessage);
+    }
+
+    // Destroy agent and exit after sendMessage completes
+    agent.destroy();
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to send message:", error);
+    if (agent!) {
+      agent.destroy();
+    }
+    process.exit(1);
+  }
+}