wave-code 0.0.4 → 0.0.5

package/src/{plain-cli.ts → print-cli.ts}

@@ -1,13 +1,14 @@
 import { Agent, AgentCallbacks } from "wave-agent-sdk";
 import { logger } from "./utils/logger.js";
+import { displayUsageSummary } from "./utils/usageSummary.js";
 
-export interface PlainCliOptions {
+export interface PrintCliOptions {
   restoreSessionId?: string;
   continueLastSession?: boolean;
   message?: string;
 }
 
-export async function startPlainCli(options: PlainCliOptions): Promise<void> {
+export async function startPrintCli(options: PrintCliOptions): Promise<void> {
   const { restoreSessionId, continueLastSession, message } = options;
 
   if (
@@ -16,7 +17,7 @@ export async function startPlainCli(options: PlainCliOptions): Promise<void> {
     !restoreSessionId
   ) {
     console.error(
-      "Plain mode requires a message: use --plain 'your message' or -p 'your message'",
+      "Print mode requires a message: use --print 'your message' or -p 'your message'",
     );
     process.exit(1);
   }
@@ -47,12 +48,29 @@ export async function startPlainCli(options: PlainCliOptions): Promise<void> {
       await agent.sendMessage(message);
     }
 
+    // Display usage summary before exit
+    try {
+      const usages = agent.usages;
+      const sessionFilePath = agent.sessionFilePath;
+      displayUsageSummary(usages, sessionFilePath);
+    } catch {
+      // Silently ignore usage summary errors
+    }
+
     // Destroy agent and exit after sendMessage completes
     agent.destroy();
     process.exit(0);
   } catch (error) {
     console.error("Failed to send message:", error);
     if (agent!) {
+      // Display usage summary even on error
+      try {
+        const usages = agent.usages;
+        const sessionFilePath = agent.sessionFilePath;
+        displayUsageSummary(usages, sessionFilePath);
+      } catch {
+        // Silently ignore usage summary errors
+      }
       agent.destroy();
     }
     process.exit(1);

package/src/utils/constants.ts

@@ -19,4 +19,4 @@ export const LOG_FILE = path.join(DATA_DIRECTORY, "app.log");
 /**
  * Pagination related constants
  */
-export const MESSAGES_PER_PAGE = 20; // Number of messages displayed per page
+export const MESSAGES_PER_PAGE = 15; // Number of messages displayed per page

package/src/utils/fileSearch.ts

@@ -0,0 +1,133 @@
+import { glob } from "glob";
+import { getGlobIgnorePatterns } from "wave-agent-sdk";
+import * as fs from "fs";
+import * as path from "path";
+
+export interface FileItem {
+  path: string;
+  type: "file" | "directory";
+}
+
+/**
+ * Check if path is a directory
+ */
+export const isDirectory = (filePath: string): boolean => {
+  try {
+    const fullPath = path.isAbsolute(filePath)
+      ? filePath
+      : path.join(process.cwd(), filePath);
+    return fs.statSync(fullPath).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Convert string paths to FileItem objects
+ */
+export const convertToFileItems = (paths: string[]): FileItem[] => {
+  return paths.map((filePath) => ({
+    path: filePath,
+    type: isDirectory(filePath) ? "directory" : "file",
+  }));
+};
+
+/**
+ * Search files and directories using glob patterns
+ */
+export const searchFiles = async (
+  query: string,
+  options?: {
+    maxResults?: number;
+    workingDirectory?: string;
+  },
+): Promise<FileItem[]> => {
+  const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
+
+  try {
+    let files: string[] = [];
+    let directories: string[] = [];
+
+    const globOptions = {
+      ignore: getGlobIgnorePatterns(workingDirectory),
+      maxDepth: 10,
+      nocase: true, // Case insensitive
+      dot: true, // Include hidden files and directories
+      cwd: workingDirectory, // Specify search root directory
+    };
+
+    if (!query.trim()) {
+      // When query is empty, show some common file types and directories
+      const commonPatterns = [
+        "**/*.ts",
+        "**/*.tsx",
+        "**/*.js",
+        "**/*.jsx",
+        "**/*.json",
+      ];
+
+      // Search files
+      const filePromises = commonPatterns.map((pattern) =>
+        glob(pattern, { ...globOptions, nodir: true }),
+      );
+
+      // Search directories (only search first level to avoid too many results)
+      const dirPromises = [glob("*/", { ...globOptions, maxDepth: 1 })];
+
+      const fileResults = await Promise.all(filePromises);
+      const dirResults = await Promise.all(dirPromises);
+
+      files = fileResults.flat();
+      directories = dirResults.flat().map((dir) => {
+        // glob returns string type paths, remove trailing slash
+        return String(dir).replace(/\/$/, "");
+      });
+    } else {
+      // Build multiple glob patterns to support more flexible search
+      const filePatterns = [
+        // Match files with filenames containing query
+        `**/*${query}*`,
+        // Match files with query in path (match directory names)
+        `**/${query}*/**/*`,
+      ];
+
+      const dirPatterns = [
+        // Match directory names containing query
+        `**/*${query}*/`,
+        // Match directories containing query in path
+        `**/${query}*/`,
+      ];
+
+      // Search files
+      const filePromises = filePatterns.map((pattern) =>
+        glob(pattern, { ...globOptions, nodir: true }),
+      );
+
+      // Search directories
+      const dirPromises = dirPatterns.map((pattern) =>
+        glob(pattern, { ...globOptions, nodir: false }),
+      );
+
+      const fileResults = await Promise.all(filePromises);
+      const dirResults = await Promise.all(dirPromises);
+
+      files = fileResults.flat();
+      directories = dirResults.flat().map((dir) => {
+        // glob returns string type paths, remove trailing slash
+        return String(dir).replace(/\/$/, "");
+      });
+    }
+
+    // Deduplicate and merge files and directories
+    const uniqueFiles = Array.from(new Set(files));
+    const uniqueDirectories = Array.from(new Set(directories));
+    const allPaths = [...uniqueDirectories, ...uniqueFiles]; // Directories first
+
+    // Limit to maximum results and convert to FileItem
+    const fileItems = convertToFileItems(allPaths.slice(0, maxResults));
+    return fileItems;
+  } catch (error) {
+    console.error("Glob search error:", error);
+    return [];
+  }
+};

package/src/utils/logger.ts

@@ -264,7 +264,7 @@ const truncateLogFileIfNeeded = (config: LogCleanupConfig): void => {
 
       // Record truncation operation
       const removedLines = lines.length - keepLines;
-      logger.info(
+      logger.debug(
         `Log file truncated: removed ${removedLines} lines, kept last ${keepLines} lines`,
       );
     }
@@ -289,7 +289,7 @@ export const cleanupLogs = async (
 
   const config = { ...getCleanupConfig(), ...customConfig };
 
-  logger.info("Starting log cleanup...", {
+  logger.debug("Starting log cleanup...", {
     maxFileSize: config.maxFileSize,
     keepLines: config.keepLines,
   });
@@ -297,5 +297,5 @@ export const cleanupLogs = async (
   // Truncate current log file (if needed)
   truncateLogFileIfNeeded(config);
 
-  logger.info("Log cleanup completed");
+  logger.debug("Log cleanup completed");
 };

package/src/utils/usageSummary.ts

@@ -0,0 +1,125 @@
+import type { Usage } from "wave-agent-sdk";
+
+/**
+ * Token summary by model
+ */
+export interface TokenSummary {
+  model: string;
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  operations: {
+    agent_calls: number;
+    compressions: number;
+  };
+}
+
+/**
+ * Calculate token usage summary by model from usage array
+ * @param usages Array of usage data from agent operations
+ * @returns Array of token summaries grouped by model
+ */
+export function calculateTokenSummary(
+  usages: Usage[],
+): Record<string, TokenSummary> {
+  const summaryMap = new Map<string, TokenSummary>();
+
+  for (const usage of usages) {
+    const model = usage.model || "unknown";
+
+    if (!summaryMap.has(model)) {
+      summaryMap.set(model, {
+        model,
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0,
+        operations: {
+          agent_calls: 0,
+          compressions: 0,
+        },
+      });
+    }
+
+    const summary = summaryMap.get(model)!;
+    summary.prompt_tokens += usage.prompt_tokens;
+    summary.completion_tokens += usage.completion_tokens;
+    summary.total_tokens += usage.total_tokens;
+
+    // Track operation types
+    if (usage.operation_type === "agent") {
+      summary.operations.agent_calls += 1;
+    } else if (usage.operation_type === "compress") {
+      summary.operations.compressions += 1;
+    }
+  }
+
+  // Convert Map to Record and sort by total tokens
+  const result: Record<string, TokenSummary> = {};
+  const sortedEntries = Array.from(summaryMap.entries()).sort(
+    (a, b) => b[1].total_tokens - a[1].total_tokens,
+  );
+
+  for (const [model, summary] of sortedEntries) {
+    result[model] = summary;
+  }
+
+  return result;
+}
+
+/**
+ * Display usage summary in a formatted way
+ * @param usages Array of usage data from agent operations
+ * @param sessionFilePath Optional session file path to display
+ */
+export function displayUsageSummary(
+  usages: Usage[],
+  sessionFilePath?: string,
+): void {
+  if (usages.length === 0) {
+    return; // No usage data to display
+  }
+
+  const summaries = calculateTokenSummary(usages);
+
+  console.log("\nToken Usage Summary:");
+  console.log("==================");
+
+  if (sessionFilePath) {
+    console.log(`Session: ${sessionFilePath}`);
+  }
+
+  let totalPrompt = 0;
+  let totalCompletion = 0;
+  let totalTokens = 0;
+  let totalAgentCalls = 0;
+  let totalCompressions = 0;
+
+  for (const [, summary] of Object.entries(summaries)) {
+    console.log(`Model: ${summary.model}`);
+    console.log(`  Prompt tokens: ${summary.prompt_tokens.toLocaleString()}`);
+    console.log(
+      `  Completion tokens: ${summary.completion_tokens.toLocaleString()}`,
+    );
+    console.log(`  Total tokens: ${summary.total_tokens.toLocaleString()}`);
+    console.log(
+      `  Operations: ${summary.operations.agent_calls} agent calls, ${summary.operations.compressions} compressions`,
+    );
+    console.log();
+
+    totalPrompt += summary.prompt_tokens;
+    totalCompletion += summary.completion_tokens;
+    totalTokens += summary.total_tokens;
+    totalAgentCalls += summary.operations.agent_calls;
+    totalCompressions += summary.operations.compressions;
+  }
+
+  if (Object.keys(summaries).length > 1) {
+    console.log("Overall Total:");
+    console.log(`  Prompt tokens: ${totalPrompt.toLocaleString()}`);
+    console.log(`  Completion tokens: ${totalCompletion.toLocaleString()}`);
+    console.log(`  Total tokens: ${totalTokens.toLocaleString()}`);
+    console.log(
+      `  Operations: ${totalAgentCalls} agent calls, ${totalCompressions} compressions`,
+    );
+  }
+}

package/dist/hooks/useBashHistorySelector.d.ts

@@ -1,15 +0,0 @@
-export declare const useBashHistorySelector: () => {
-    showBashHistorySelector: boolean;
-    bashHistorySearchQuery: string;
-    activateBashHistorySelector: (position: number) => void;
-    handleBashHistorySelect: (command: string, inputText: string, cursorPosition: number) => {
-        newInput: string;
-        newCursorPosition: number;
-    };
-    handleBashHistoryExecute: (command: string) => string;
-    handleCancelBashHistorySelect: () => void;
-    updateBashHistorySearchQuery: (query: string) => void;
-    checkForExclamationDeletion: (cursorPosition: number) => boolean;
-    exclamationPosition: number;
-};
-//# sourceMappingURL=useBashHistorySelector.d.ts.map

package/dist/hooks/useBashHistorySelector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useBashHistorySelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useBashHistorySelector.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;4CAK0B,MAAM;uCAOrD,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;wCAyBN,MAAM;;0CAOJ,MAAM;kDAK5C,MAAM;;CAyB1B,CAAC"}

package/dist/hooks/useBashHistorySelector.js

@@ -1,61 +0,0 @@
-import { useState, useCallback } from "react";
-export const useBashHistorySelector = () => {
-    const [showBashHistorySelector, setShowBashHistorySelector] = useState(false);
-    const [exclamationPosition, setExclamationPosition] = useState(-1);
-    const [bashHistorySearchQuery, setBashHistorySearchQuery] = useState("");
-    const activateBashHistorySelector = useCallback((position) => {
-        setShowBashHistorySelector(true);
-        setExclamationPosition(position);
-        setBashHistorySearchQuery("");
-    }, []);
-    const handleBashHistorySelect = useCallback((command, inputText, cursorPosition) => {
-        if (exclamationPosition >= 0) {
-            // Replace ! and search query with selected command
-            const beforeExclamation = inputText.substring(0, exclamationPosition);
-            const afterQuery = inputText.substring(cursorPosition);
-            const newInput = beforeExclamation + `!${command}` + afterQuery;
-            const newCursorPosition = beforeExclamation.length + command.length + 1;
-            setShowBashHistorySelector(false);
-            setExclamationPosition(-1);
-            setBashHistorySearchQuery("");
-            return { newInput, newCursorPosition };
-        }
-        return { newInput: inputText, newCursorPosition: cursorPosition };
-    }, [exclamationPosition]);
-    const handleCancelBashHistorySelect = useCallback(() => {
-        setShowBashHistorySelector(false);
-        setExclamationPosition(-1);
-        setBashHistorySearchQuery("");
-    }, []);
-    const handleBashHistoryExecute = useCallback((command) => {
-        setShowBashHistorySelector(false);
-        setExclamationPosition(-1);
-        setBashHistorySearchQuery("");
-        return command; // Return command to execute
-    }, []);
-    const updateBashHistorySearchQuery = useCallback((query) => {
-        setBashHistorySearchQuery(query);
-    }, []);
-    const checkForExclamationDeletion = useCallback((cursorPosition) => {
-        if (showBashHistorySelector && cursorPosition <= exclamationPosition) {
-            handleCancelBashHistorySelect();
-            return true;
-        }
-        return false;
-    }, [
-        showBashHistorySelector,
-        exclamationPosition,
-        handleCancelBashHistorySelect,
-    ]);
-    return {
-        showBashHistorySelector,
-        bashHistorySearchQuery,
-        activateBashHistorySelector,
-        handleBashHistorySelect,
-        handleBashHistoryExecute,
-        handleCancelBashHistorySelect,
-        updateBashHistorySearchQuery,
-        checkForExclamationDeletion,
-        exclamationPosition,
-    };
-};

package/dist/hooks/useCommandSelector.d.ts

@@ -1,24 +0,0 @@
-export interface UseCommandSelectorParams {
-    onShowBashManager?: () => void;
-    onShowMcpManager?: () => void;
-    sendMessage?: (content: string) => Promise<void>;
-    hasSlashCommand?: (commandId: string) => boolean;
-}
-export declare const useCommandSelector: ({ onShowBashManager, onShowMcpManager, sendMessage, hasSlashCommand, }: UseCommandSelectorParams) => {
-    showCommandSelector: boolean;
-    commandSearchQuery: string;
-    activateCommandSelector: (position: number) => void;
-    handleCommandSelect: (command: string, inputText: string, cursorPosition: number) => {
-        newInput: string;
-        newCursorPosition: number;
-    };
-    handleCommandInsert: (command: string, inputText: string, cursorPosition: number) => {
-        newInput: string;
-        newCursorPosition: number;
-    };
-    handleCancelCommandSelect: () => void;
-    updateCommandSearchQuery: (query: string) => void;
-    checkForSlashDeletion: (cursorPosition: number) => boolean;
-    slashPosition: number;
-};
-//# sourceMappingURL=useCommandSelector.d.ts.map

package/dist/hooks/useCommandSelector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useCommandSelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useCommandSelector.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,wBAAwB;IACvC,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CAClD;AAED,eAAO,MAAM,kBAAkB,GAAI,wEAKhC,wBAAwB;;;wCAK8B,MAAM;mCA2BjD,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;mCApBjD,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;;sCA8ER,MAAM;4CAKxC,MAAM;;CAqB1B,CAAC"}

package/dist/hooks/useCommandSelector.js

@@ -1,98 +0,0 @@
-import { useState, useCallback } from "react";
-export const useCommandSelector = ({ onShowBashManager, onShowMcpManager, sendMessage, hasSlashCommand, }) => {
-    const [showCommandSelector, setShowCommandSelector] = useState(false);
-    const [slashPosition, setSlashPosition] = useState(-1);
-    const [commandSearchQuery, setCommandSearchQuery] = useState("");
-    const activateCommandSelector = useCallback((position) => {
-        setShowCommandSelector(true);
-        setSlashPosition(position);
-        setCommandSearchQuery("");
-    }, []);
-    const handleCommandInsert = useCallback((command, inputText, cursorPosition) => {
-        if (slashPosition >= 0) {
-            // Replace content from / to current cursor position with /command_name + space
-            const beforeSlash = inputText.substring(0, slashPosition);
-            const afterQuery = inputText.substring(cursorPosition);
-            const newInput = beforeSlash + `/${command} ` + afterQuery;
-            const newCursorPosition = beforeSlash.length + command.length + 2; // +2 for "/" and " "
-            setShowCommandSelector(false);
-            setSlashPosition(-1);
-            setCommandSearchQuery("");
-            return { newInput, newCursorPosition };
-        }
-        return { newInput: inputText, newCursorPosition: cursorPosition };
-    }, [slashPosition]);
-    const handleCommandSelect = useCallback((command, inputText, cursorPosition) => {
-        if (slashPosition >= 0) {
-            // Replace command part, keep other content
-            const beforeSlash = inputText.substring(0, slashPosition);
-            const afterQuery = inputText.substring(cursorPosition);
-            const newInput = beforeSlash + afterQuery;
-            const newCursorPosition = beforeSlash.length;
-            // Execute command asynchronously
-            (async () => {
-                // First check if it's an agent command
-                let commandExecuted = false;
-                if (sendMessage && hasSlashCommand && hasSlashCommand(command)) {
-                    // Execute complete command (replace partial input with complete command name)
-                    const fullCommand = `/${command}`;
-                    try {
-                        await sendMessage(fullCommand);
-                        commandExecuted = true;
-                    }
-                    catch (error) {
-                        console.error("Failed to execute slash command:", error);
-                    }
-                }
-                // If not an agent command or execution failed, check local commands
-                if (!commandExecuted) {
-                    if (command === "bashes" && onShowBashManager) {
-                        onShowBashManager();
-                        commandExecuted = true;
-                    }
-                    else if (command === "mcp" && onShowMcpManager) {
-                        onShowMcpManager();
-                        commandExecuted = true;
-                    }
-                }
-            })();
-            setShowCommandSelector(false);
-            setSlashPosition(-1);
-            setCommandSearchQuery("");
-            return { newInput, newCursorPosition };
-        }
-        return { newInput: inputText, newCursorPosition: cursorPosition };
-    }, [
-        slashPosition,
-        onShowBashManager,
-        onShowMcpManager,
-        sendMessage,
-        hasSlashCommand,
-    ]);
-    const handleCancelCommandSelect = useCallback(() => {
-        setShowCommandSelector(false);
-        setSlashPosition(-1);
-        setCommandSearchQuery("");
-    }, []);
-    const updateCommandSearchQuery = useCallback((query) => {
-        setCommandSearchQuery(query);
-    }, []);
-    const checkForSlashDeletion = useCallback((cursorPosition) => {
-        if (showCommandSelector && cursorPosition <= slashPosition) {
-            handleCancelCommandSelect();
-            return true;
-        }
-        return false;
-    }, [showCommandSelector, slashPosition, handleCancelCommandSelect]);
-    return {
-        showCommandSelector,
-        commandSearchQuery,
-        activateCommandSelector,
-        handleCommandSelect,
-        handleCommandInsert,
-        handleCancelCommandSelect,
-        updateCommandSearchQuery,
-        checkForSlashDeletion,
-        slashPosition,
-    };
-};

package/dist/hooks/useFileSelector.d.ts

@@ -1,16 +0,0 @@
-import { FileItem } from "../components/FileSelector.js";
-export declare const useFileSelector: () => {
-    showFileSelector: boolean;
-    filteredFiles: FileItem[];
-    searchQuery: string;
-    activateFileSelector: (position: number) => void;
-    handleFileSelect: (filePath: string, inputText: string, cursorPosition: number) => {
-        newInput: string;
-        newCursorPosition: number;
-    };
-    handleCancelFileSelect: () => void;
-    updateSearchQuery: (query: string) => void;
-    checkForAtDeletion: (cursorPosition: number) => boolean;
-    atPosition: number;
-};
-//# sourceMappingURL=useFileSelector.d.ts.map

package/dist/hooks/useFileSelector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useFileSelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useFileSelector.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,eAAO,MAAM,eAAe;;;;qCA2Jb,MAAM;iCAWN,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;;+BA2BhB,MAAM;yCAKjC,MAAM;;CAqB1B,CAAC"}