wave-code 0.0.4 → 0.0.6

package/src/print-cli.ts

@@ -0,0 +1,160 @@
+import { Agent, AgentCallbacks } from "wave-agent-sdk";
+import { displayUsageSummary } from "./utils/usageSummary.js";
+
+export interface PrintCliOptions {
+  restoreSessionId?: string;
+  continueLastSession?: boolean;
+  message?: string;
+  showStats?: boolean;
+}
+
+function displayTimingInfo(startTime: Date, showStats: boolean): void {
+  // Skip timing info in test environment or if stats are disabled
+  if (process.env.NODE_ENV === "test" || process.env.VITEST || !showStats) {
+    return;
+  }
+
+  const endTime = new Date();
+  const duration = endTime.getTime() - startTime.getTime();
+
+  process.stdout.write(`\n\n📅 Start time: ${startTime.toISOString()}\n`);
+  process.stdout.write(`📅 End time: ${endTime.toISOString()}\n`);
+  process.stdout.write(`⏱️  Duration: ${duration}ms\n`);
+}
+
+export async function startPrintCli(options: PrintCliOptions): Promise<void> {
+  const startTime = new Date();
+  const {
+    restoreSessionId,
+    continueLastSession,
+    message,
+    showStats = false,
+  } = options;
+
+  if (
+    (!message || message.trim() === "") &&
+    !continueLastSession &&
+    !restoreSessionId
+  ) {
+    console.error(
+      "Print mode requires a message: use --print 'your message' or -p 'your message'",
+    );
+    process.exit(1);
+  }
+
+  let agent: Agent;
+
+  // Setup callbacks for agent
+  const callbacks: AgentCallbacks = {
+    onAssistantMessageAdded: () => {
+      // Assistant message started - no content to output yet
+      process.stdout.write("\n");
+    },
+    onAssistantContentUpdated: (chunk: string) => {
+      // FR-001: Stream content updates for real-time display - output only the new chunk
+      process.stdout.write(chunk);
+    },
+
+    // Tool block callback - display tool name when tool starts
+    onToolBlockUpdated: (params) => {
+      // Print tool name only during 'running' stage (happens once per tool call)
+      if (params.stage === "running" && params.name) {
+        process.stdout.write(`\n🔧 ${params.name}`);
+        if (params.compactParams) {
+          process.stdout.write(` ${params.compactParams}`);
+        }
+        process.stdout.write(`\n`);
+      }
+    },
+
+    // Subagent block callbacks
+    onSubAgentBlockAdded: (subagentId: string, parameters) => {
+      // Display subagent creation with indentation
+      process.stdout.write(
+        `\n🤖 Subagent [${parameters.subagent_type}]: ${parameters.description}\n`,
+      );
+    },
+    onSubAgentBlockUpdated: (subagentId: string, status) => {
+      // Display subagent status updates
+      const statusIconMap = {
+        active: "🔄",
+        completed: "✅",
+        error: "❌",
+        aborted: "⚠️",
+      } as const;
+
+      const statusIcon = statusIconMap[status] ?? "🔄";
+      process.stdout.write(`   ${statusIcon} Subagent status: ${status}\n`);
+    },
+    // Subagent message callbacks
+    onSubagentAssistantMessageAdded: () => {
+      // Subagent assistant message started - add indentation
+      process.stdout.write("\n   ");
+    },
+    onSubagentAssistantContentUpdated: (_subagentId: string, chunk: string) => {
+      // Stream subagent content with indentation - output only the new chunk
+      process.stdout.write(chunk);
+    },
+    onSubagentUserMessageAdded: (_subagentId: string, params) => {
+      // Display subagent user messages with indentation
+      process.stdout.write(`\n   👤 User: ${params.content}\n`);
+    },
+    // Error block callback
+    onErrorBlockAdded: (error: string) => {
+      // Display error blocks with distinct formatting
+      process.stdout.write(`\n❌ Error: ${error}\n`);
+    },
+  };
+
+  try {
+    // Initialize agent
+    agent = await Agent.create({
+      callbacks,
+      restoreSessionId,
+      continueLastSession,
+    });
+
+    // Send message if provided and not empty
+    if (message && message.trim() !== "") {
+      await agent.sendMessage(message);
+    }
+
+    // Display usage summary before exit
+    if (showStats) {
+      try {
+        const usages = agent.usages;
+        const sessionFilePath = agent.sessionFilePath;
+        displayUsageSummary(usages, sessionFilePath);
+      } catch {
+        // Silently ignore usage summary errors
+      }
+    }
+
+    // Display timing information
+    displayTimingInfo(startTime, showStats);
+
+    // Destroy agent and exit after sendMessage completes
+    await agent.destroy();
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to send message:", error);
+    if (agent!) {
+      // Display usage summary even on error
+      if (showStats) {
+        try {
+          const usages = agent.usages;
+          const sessionFilePath = agent.sessionFilePath;
+          displayUsageSummary(usages, sessionFilePath);
+        } catch {
+          // Silently ignore usage summary errors
+        }
+      }
+
+      // Display timing information even on error
+      displayTimingInfo(startTime, showStats);
+
+      await 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,234 @@
+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;
+  };
+  // Cache-related tokens (for Claude models)
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_creation?: {
+    ephemeral_5m_input_tokens: number;
+    ephemeral_1h_input_tokens: 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;
+
+    // Handle cache tokens if present and non-zero
+    if (usage.cache_read_input_tokens && usage.cache_read_input_tokens > 0) {
+      summary.cache_read_input_tokens =
+        (summary.cache_read_input_tokens || 0) + usage.cache_read_input_tokens;
+    }
+    if (
+      usage.cache_creation_input_tokens &&
+      usage.cache_creation_input_tokens > 0
+    ) {
+      summary.cache_creation_input_tokens =
+        (summary.cache_creation_input_tokens || 0) +
+        usage.cache_creation_input_tokens;
+    }
+    if (
+      usage.cache_creation &&
+      (usage.cache_creation.ephemeral_5m_input_tokens > 0 ||
+        usage.cache_creation.ephemeral_1h_input_tokens > 0)
+    ) {
+      if (!summary.cache_creation) {
+        summary.cache_creation = {
+          ephemeral_5m_input_tokens: 0,
+          ephemeral_1h_input_tokens: 0,
+        };
+      }
+      summary.cache_creation.ephemeral_5m_input_tokens +=
+        usage.cache_creation.ephemeral_5m_input_tokens || 0;
+      summary.cache_creation.ephemeral_1h_input_tokens +=
+        usage.cache_creation.ephemeral_1h_input_tokens || 0;
+    }
+
+    // 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;
+  let totalCacheRead = 0;
+  let totalCacheCreation = 0;
+  let totalCache5m = 0;
+  let totalCache1h = 0;
+  let hasCacheData = false;
+
+  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()}`);
+
+    // Display cache information if available
+    if (
+      summary.cache_read_input_tokens ||
+      summary.cache_creation_input_tokens ||
+      summary.cache_creation
+    ) {
+      hasCacheData = true;
+      console.log("  Cache Usage:");
+
+      if (
+        summary.cache_read_input_tokens &&
+        summary.cache_read_input_tokens > 0
+      ) {
+        console.log(
+          `    Read from cache: ${summary.cache_read_input_tokens.toLocaleString()} tokens`,
+        );
+        totalCacheRead += summary.cache_read_input_tokens;
+      }
+
+      if (
+        summary.cache_creation_input_tokens &&
+        summary.cache_creation_input_tokens > 0
+      ) {
+        console.log(
+          `    Created cache: ${summary.cache_creation_input_tokens.toLocaleString()} tokens`,
+        );
+        totalCacheCreation += summary.cache_creation_input_tokens;
+      }
+
+      if (summary.cache_creation) {
+        if (summary.cache_creation.ephemeral_5m_input_tokens > 0) {
+          console.log(
+            `    5m cache: ${summary.cache_creation.ephemeral_5m_input_tokens.toLocaleString()} tokens`,
+          );
+          totalCache5m += summary.cache_creation.ephemeral_5m_input_tokens;
+        }
+        if (summary.cache_creation.ephemeral_1h_input_tokens > 0) {
+          console.log(
+            `    1h cache: ${summary.cache_creation.ephemeral_1h_input_tokens.toLocaleString()} tokens`,
+          );
+          totalCache1h += summary.cache_creation.ephemeral_1h_input_tokens;
+        }
+      }
+    }
+
+    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()}`);
+
+    if (hasCacheData) {
+      console.log("  Cache Usage:");
+      if (totalCacheRead > 0) {
+        console.log(
+          `    Read from cache: ${totalCacheRead.toLocaleString()} tokens`,
+        );
+      }
+      if (totalCacheCreation > 0) {
+        console.log(
+          `    Created cache: ${totalCacheCreation.toLocaleString()} tokens`,
+        );
+      }
+      if (totalCache5m > 0) {
+        console.log(`    5m cache: ${totalCache5m.toLocaleString()} tokens`);
+      }
+      if (totalCache1h > 0) {
+        console.log(`    1h cache: ${totalCache1h.toLocaleString()} tokens`);
+      }
+    }
+
+    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"}