wave-code 0.12.0 → 0.12.2

package/src/utils/logger.ts

@@ -10,6 +10,7 @@
 
 import * as fs from "fs";
 import { Chalk } from "chalk";
+import { getLastLines } from "wave-agent-sdk";
 import { LOG_FILE, DATA_DIRECTORY } from "./constants.js";
 
 const chalk = new Chalk({ level: 3 });
@@ -124,21 +125,23 @@ const formatArg = (arg: unknown): string => {
   if (arg === null) return "null";
   if (arg === undefined) return "undefined";
 
+  let result: string;
   if (arg instanceof Error) {
     // Special handling for Error objects, display stack or message
-    return arg.stack || arg.message || String(arg);
-  }
-
-  if (typeof arg === "object") {
+    result = arg.stack || arg.message || String(arg);
+  } else if (typeof arg === "object") {
     try {
-      return JSON.stringify(arg, null, 2);
+      result = JSON.stringify(arg);
     } catch {
       // If JSON.stringify fails, fallback to String()
-      return String(arg);
+      result = String(arg);
     }
+  } else {
+    result = String(arg);
   }
 
-  return String(arg);
+  // Ensure no newlines in the result to keep log entries single-line
+  return result.replace(/[\n\r]+/g, " ");
 };
 
 /**
@@ -267,19 +270,14 @@ const truncateLogFileIfNeeded = (config: LogCleanupConfig): void => {
     // If file size exceeds limit, truncate file
     if (stats.size > config.maxFileSize) {
       const content = fs.readFileSync(logFile, "utf8");
-      const lines = content.split("\n");
-
-      // Keep the last specified number of lines
-      const keepLines = Math.min(config.keepLines, lines.length);
-      const truncatedContent = lines.slice(-keepLines).join("\n");
+      const truncatedContent = getLastLines(content, config.keepLines);
 
       // Write truncated content
       fs.writeFileSync(logFile, truncatedContent);
 
       // Record truncation operation
-      const removedLines = lines.length - keepLines;
       logger.debug(
-        `Log file truncated: removed ${removedLines} lines, kept last ${keepLines} lines`,
+        `Log file truncated: file size ${stats.size} exceeded limit ${config.maxFileSize}, kept last ${config.keepLines} lines`,
       );
     }
   } catch (error) {

package/src/utils/throttle.ts

@@ -0,0 +1,75 @@
+export interface ThrottleOptions {
+  leading?: boolean;
+  trailing?: boolean;
+}
+
+export interface ThrottledFunction<T extends (...args: unknown[]) => void> {
+  (...args: Parameters<T>): void;
+  cancel: () => void;
+  flush: () => void;
+}
+
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds.
+ */
+export function throttle<T extends (...args: unknown[]) => void>(
+  func: T,
+  wait: number,
+  options: ThrottleOptions = { leading: true, trailing: true },
+): ThrottledFunction<T> {
+  let timeoutId: NodeJS.Timeout | null = null;
+  let lastArgs: Parameters<T> | null = null;
+  let lastCallTime = 0;
+
+  const invokeFunc = () => {
+    if (lastArgs) {
+      func(...lastArgs);
+      lastCallTime = Date.now();
+      lastArgs = null;
+    }
+  };
+
+  const throttled = (...args: Parameters<T>) => {
+    const now = Date.now();
+    const remaining = wait - (now - lastCallTime);
+
+    lastArgs = args;
+
+    if (remaining <= 0 || remaining > wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (options.leading !== false || lastCallTime !== 0) {
+        invokeFunc();
+      } else {
+        lastCallTime = now;
+      }
+    } else if (!timeoutId && options.trailing !== false) {
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        invokeFunc();
+      }, remaining);
+    }
+  };
+
+  throttled.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastArgs = null;
+    lastCallTime = 0;
+  };
+
+  throttled.flush = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    invokeFunc();
+  };
+
+  return throttled as ThrottledFunction<T>;
+}

package/src/utils/toolParameterTransforms.ts

@@ -3,7 +3,11 @@
  * Forces type judgment based on tool name using type assertions
  */
 
-import { type Change, type EditToolParameters } from "wave-agent-sdk";
+import {
+  type Change,
+  type WriteToolParameters,
+  type EditToolParameters,
+} from "wave-agent-sdk";
 import { logger } from "./logger.js";
 
 /**
@@ -22,6 +26,20 @@ function parseToolParameters(parameters: string): unknown {
   }
 }
 
+/**
+ * Transform Write tool parameters to changes
+ */
+export function transformWriteParameters(
+  parameters: WriteToolParameters,
+): Change[] {
+  return [
+    {
+      oldContent: "", // No previous content for write operations
+      newContent: parameters.content,
+    },
+  ];
+}
+
 /**
  * Transform Edit tool parameters to changes
  */
@@ -54,6 +72,10 @@ export function transformToolBlockToChanges(
 
     let changes: Change[] = [];
     switch (toolName) {
+      case "Write":
+        changes = transformWriteParameters(parsedParams as WriteToolParameters);
+        break;
+
       case "Edit":
         changes = transformEditParameters(parsedParams as EditToolParameters);
         break;

package/src/utils/worktree.ts

@@ -13,8 +13,6 @@ export interface WorktreeSession {
   isNew: boolean;
 }
 
-export const WORKTREE_DIR = ".wave/worktrees";
-
 /**
  * Create a new git worktree
  * @param name Worktree name
@@ -23,7 +21,13 @@ export const WORKTREE_DIR = ".wave/worktrees";
  */
 export function createWorktree(name: string, cwd: string): WorktreeSession {
   const repoRoot = getGitMainRepoRoot(cwd);
-  const worktreePath = path.join(repoRoot, WORKTREE_DIR, name);
+  const projectName = path.basename(repoRoot);
+  const worktreePath = path.join(
+    repoRoot,
+    "..",
+    `${projectName}.worktrees`,
+    name,
+  );
   const branchName = `worktree-${name}`;
   const baseBranch = getDefaultRemoteBranch(cwd);