wave-code 0.0.6 → 0.0.8

package/src/print-cli.ts

@@ -6,6 +6,7 @@ export interface PrintCliOptions {
   continueLastSession?: boolean;
   message?: string;
   showStats?: boolean;
+  bypassPermissions?: boolean;
 }
 
 function displayTimingInfo(startTime: Date, showStats: boolean): void {
@@ -29,6 +30,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     continueLastSession,
     message,
     showStats = false,
+    bypassPermissions,
   } = options;
 
   if (
@@ -43,14 +45,31 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
   }
 
   let agent: Agent;
+  let isReasoning = false;
+  let isContent = false;
+  const subagentReasoningStates = new Map<string, boolean>();
+  const subagentContentStates = new Map<string, boolean>();
 
   // Setup callbacks for agent
   const callbacks: AgentCallbacks = {
     onAssistantMessageAdded: () => {
+      isReasoning = false;
+      isContent = false;
       // Assistant message started - no content to output yet
       process.stdout.write("\n");
     },
+    onAssistantReasoningUpdated: (chunk: string) => {
+      if (!isReasoning) {
+        process.stdout.write("💭 Reasoning:\n");
+        isReasoning = true;
+      }
+      process.stdout.write(chunk);
+    },
     onAssistantContentUpdated: (chunk: string) => {
+      if (isReasoning && !isContent) {
+        process.stdout.write("\n\n📝 Response:\n");
+        isContent = true;
+      }
       // FR-001: Stream content updates for real-time display - output only the new chunk
       process.stdout.write(chunk);
     },
@@ -87,11 +106,30 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       process.stdout.write(`   ${statusIcon} Subagent status: ${status}\n`);
     },
     // Subagent message callbacks
-    onSubagentAssistantMessageAdded: () => {
+    onSubagentAssistantMessageAdded: (subagentId: string) => {
+      subagentReasoningStates.set(subagentId, false);
+      subagentContentStates.set(subagentId, false);
       // Subagent assistant message started - add indentation
       process.stdout.write("\n   ");
     },
-    onSubagentAssistantContentUpdated: (_subagentId: string, chunk: string) => {
+    onSubagentAssistantReasoningUpdated: (
+      subagentId: string,
+      chunk: string,
+    ) => {
+      if (!subagentReasoningStates.get(subagentId)) {
+        process.stdout.write("💭 Reasoning: ");
+        subagentReasoningStates.set(subagentId, true);
+      }
+      process.stdout.write(chunk);
+    },
+    onSubagentAssistantContentUpdated: (subagentId: string, chunk: string) => {
+      if (
+        subagentReasoningStates.get(subagentId) &&
+        !subagentContentStates.get(subagentId)
+      ) {
+        process.stdout.write("\n   📝 Response: ");
+        subagentContentStates.set(subagentId, true);
+      }
       // Stream subagent content with indentation - output only the new chunk
       process.stdout.write(chunk);
     },
@@ -112,6 +150,8 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       callbacks,
       restoreSessionId,
       continueLastSession,
+      permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
+      // 保持流式模式以获得更好的命令行用户体验
     });
 
     // Send message if provided and not empty

package/src/utils/toolParameterTransforms.ts

@@ -0,0 +1,104 @@
+/**
+ * Tool parameter transformation utilities for UI rendering
+ * Forces type judgment based on tool name using type assertions
+ */
+
+import {
+  type Change,
+  type WriteToolParameters,
+  type EditToolParameters,
+  type MultiEditToolParameters,
+} from "wave-agent-sdk";
+import { logger } from "./logger.js";
+
+/**
+ * Parse tool block parameters
+ */
+function parseToolParameters(parameters: string): unknown {
+  if (!parameters) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(parameters);
+  } catch (error) {
+    logger.warn("Failed to parse tool parameters:", error);
+    return {};
+  }
+}
+
+/**
+ * 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
+ */
+export function transformEditParameters(
+  parameters: EditToolParameters,
+): Change[] {
+  return [
+    {
+      oldContent: parameters.old_string,
+      newContent: parameters.new_string,
+    },
+  ];
+}
+
+/**
+ * Transform MultiEdit tool parameters to changes
+ */
+export function transformMultiEditParameters(
+  parameters: MultiEditToolParameters,
+): Change[] {
+  return parameters.edits.map((edit) => ({
+    oldContent: edit.old_string,
+    newContent: edit.new_string,
+  }));
+}
+
+/**
+ * Transform tool block parameters into standardized Change[] array for diff display
+ * Forces type judgment based on tool name using type assertions
+ */
+export function transformToolBlockToChanges(
+  toolName: string,
+  parameters: string,
+): Change[] {
+  try {
+    if (!toolName) {
+      return [];
+    }
+
+    const parsedParams = parseToolParameters(parameters);
+
+    switch (toolName) {
+      case "Write":
+        return transformWriteParameters(parsedParams as WriteToolParameters);
+
+      case "Edit":
+        return transformEditParameters(parsedParams as EditToolParameters);
+
+      case "MultiEdit":
+        return transformMultiEditParameters(
+          parsedParams as MultiEditToolParameters,
+        );
+
+      default:
+        return [];
+    }
+  } catch (error) {
+    logger.warn("Failed to transform tool block to changes:", error);
+    return [];
+  }
+}

package/dist/components/DiffViewer.d.ts

@@ -1,9 +0,0 @@
-import React from "react";
-import type { DiffBlock } from "wave-agent-sdk";
-interface DiffViewerProps {
-    block: DiffBlock;
-    isStatic?: boolean;
-}
-export declare const DiffViewer: React.FC<DiffViewerProps>;
-export {};
-//# sourceMappingURL=DiffViewer.d.ts.map

package/dist/components/DiffViewer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DiffViewer.d.ts","sourceRoot":"","sources":["../../src/components/DiffViewer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,UAAU,eAAe;IACvB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAwCD,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAkRhD,CAAC"}

package/dist/components/DiffViewer.js

@@ -1,221 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { Text, Box } from "ink";
-import { diffWords } from "diff";
-// Render word-level diff
-const renderWordLevelDiff = (removedLine, addedLine) => {
-    const changes = diffWords(removedLine, addedLine);
-    const removedParts = [];
-    const addedParts = [];
-    changes.forEach((part, index) => {
-        if (part.removed) {
-            removedParts.push(_jsx(Text, { color: "black", backgroundColor: "red", children: part.value }, `removed-${index}`));
-        }
-        else if (part.added) {
-            addedParts.push(_jsx(Text, { color: "black", backgroundColor: "green", children: part.value }, `added-${index}`));
-        }
-        else {
-            // Unchanged parts, need to display on both sides
-            removedParts.push(_jsx(Text, { color: "red", children: part.value }, `removed-unchanged-${index}`));
-            addedParts.push(_jsx(Text, { color: "green", children: part.value }, `added-unchanged-${index}`));
-        }
-    });
-    return { removedParts, addedParts };
-};
-export const DiffViewer = ({ block, isStatic = true, }) => {
-    const { diffResult } = block;
-    const diffLines = useMemo(() => {
-        if (!diffResult)
-            return [];
-        const lines = [];
-        let originalLineNum = 1;
-        let modifiedLineNum = 1;
-        const maxContext = 3; // Show at most 3 lines of context
-        // Buffer for storing context
-        let contextBuffer = [];
-        let hasAnyChanges = false;
-        let afterChangeContext = 0;
-        // Temporarily store adjacent deleted and added lines for word-level comparison
-        let pendingRemovedLines = [];
-        const flushPendingLines = () => {
-            pendingRemovedLines.forEach((line) => {
-                lines.push({
-                    content: line.content,
-                    type: "removed",
-                    lineNumber: line.lineNumber,
-                    rawContent: line.rawContent,
-                });
-            });
-            pendingRemovedLines = [];
-        };
-        diffResult.forEach((part) => {
-            const partLines = part.value.split("\n");
-            // Remove the last empty line (produced by split)
-            if (partLines[partLines.length - 1] === "") {
-                partLines.pop();
-            }
-            if (part.removed) {
-                // If this is the first change encountered, add preceding context
-                if (!hasAnyChanges) {
-                    // Take the last few lines from the buffer as preceding context
-                    const preContext = contextBuffer.slice(-maxContext);
-                    if (contextBuffer.length > maxContext) {
-                        lines.push({
-                            content: "...",
-                            type: "separator",
-                        });
-                    }
-                    lines.push(...preContext);
-                }
-                else if (afterChangeContext > maxContext) {
-                    // If there's too much context after the previous change, add a separator
-                    lines.push({
-                        content: "...",
-                        type: "separator",
-                    });
-                }
-                // Temporarily store deleted lines, waiting for possible added lines for word-level comparison
-                partLines.forEach((line) => {
-                    pendingRemovedLines.push({
-                        content: `- ${line}`,
-                        rawContent: line,
-                        lineNumber: originalLineNum++,
-                    });
-                });
-                hasAnyChanges = true;
-                afterChangeContext = 0;
-                contextBuffer = []; // Clear buffer
-            }
-            else if (part.added) {
-                // If this is the first change encountered, add preceding context
-                if (!hasAnyChanges) {
-                    const preContext = contextBuffer.slice(-maxContext);
-                    if (contextBuffer.length > maxContext) {
-                        lines.push({
-                            content: "...",
-                            type: "separator",
-                        });
-                    }
-                    lines.push(...preContext);
-                }
-                else if (afterChangeContext > maxContext) {
-                    lines.push({
-                        content: "...",
-                        type: "separator",
-                    });
-                }
-                // Process added lines, try to do word-level comparison with pending deleted lines
-                partLines.forEach((line, index) => {
-                    if (index < pendingRemovedLines.length) {
-                        // Has corresponding deleted line, perform word-level comparison
-                        const removedLine = pendingRemovedLines[index];
-                        const wordDiff = renderWordLevelDiff(removedLine.rawContent, line);
-                        // Add deleted line (with word-level highlighting)
-                        lines.push({
-                            content: `- ${removedLine.rawContent}`,
-                            type: "removed",
-                            lineNumber: removedLine.lineNumber,
-                            rawContent: removedLine.rawContent,
-                            wordDiff: {
-                                removedParts: wordDiff.removedParts,
-                                addedParts: [],
-                            },
-                        });
-                        // Add added line (with word-level highlighting)
-                        lines.push({
-                            content: `+ ${line}`,
-                            type: "added",
-                            lineNumber: modifiedLineNum++,
-                            rawContent: line,
-                            wordDiff: { removedParts: [], addedParts: wordDiff.addedParts },
-                        });
-                    }
-                    else {
-                        // No corresponding deleted line, directly add the added line
-                        lines.push({
-                            content: `+ ${line}`,
-                            type: "added",
-                            lineNumber: modifiedLineNum++,
-                            rawContent: line,
-                        });
-                    }
-                });
-                // If there are more deleted lines than added lines, add remaining deleted lines
-                for (let i = partLines.length; i < pendingRemovedLines.length; i++) {
-                    const removedLine = pendingRemovedLines[i];
-                    lines.push({
-                        content: removedLine.content,
-                        type: "removed",
-                        lineNumber: removedLine.lineNumber,
-                        rawContent: removedLine.rawContent,
-                    });
-                }
-                pendingRemovedLines = []; // Clear pending deleted lines
-                hasAnyChanges = true;
-                afterChangeContext = 0;
-                contextBuffer = [];
-            }
-            else {
-                // Before processing unchanged lines, first clear pending deleted lines
-                flushPendingLines();
-                // Process unchanged lines
-                partLines.forEach((line) => {
-                    const contextLine = {
-                        content: `  ${line}`,
-                        type: "unchanged",
-                        lineNumber: originalLineNum,
-                    };
-                    if (hasAnyChanges) {
-                        // If there are already changes, these are post-change context
-                        if (afterChangeContext < maxContext) {
-                            lines.push(contextLine);
-                            afterChangeContext++;
-                        }
-                    }
-                    else {
-                        // If no changes yet, add to buffer
-                        contextBuffer.push(contextLine);
-                    }
-                    originalLineNum++;
-                    modifiedLineNum++;
-                });
-            }
-        });
-        // Handle remaining deleted lines at the end
-        flushPendingLines();
-        return lines;
-    }, [diffResult]);
-    // Truncate to last 10 lines for non-static items
-    const displayLines = useMemo(() => {
-        if (isStatic) {
-            return diffLines;
-        }
-        const MAX_LINES = 10;
-        if (diffLines.length <= MAX_LINES) {
-            return diffLines;
-        }
-        return diffLines.slice(-MAX_LINES);
-    }, [diffLines, isStatic]);
-    if (!diffResult || diffResult.length === 0) {
-        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "gray", children: "No changes detected" }) }));
-    }
-    // Show traditional diff view
-    return (_jsx(Box, { flexDirection: "column", children: _jsx(Box, { flexDirection: "column", children: _jsx(Box, { flexDirection: "column", children: displayLines.map((line, index) => {
-                    // If has word-level diff, render special effects
-                    if (line.wordDiff) {
-                        const prefix = line.type === "removed" ? "- " : "+ ";
-                        const parts = line.type === "removed"
-                            ? line.wordDiff.removedParts
-                            : line.wordDiff.addedParts;
-                        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: line.type === "removed" ? "red" : "green", children: prefix }), _jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: parts })] }, index));
-                    }
-                    // Normal rendering
-                    return (_jsx(Text, { color: line.type === "added"
-                            ? "green"
-                            : line.type === "removed"
-                                ? "red"
-                                : line.type === "separator"
-                                    ? "gray"
-                                    : "white", dimColor: line.type === "separator", children: line.content }, index));
-                }) }) }) }));
-};

package/dist/utils/fileSearch.d.ts

@@ -1,20 +0,0 @@
-export interface FileItem {
-    path: string;
-    type: "file" | "directory";
-}
-/**
- * Check if path is a directory
- */
-export declare const isDirectory: (filePath: string) => boolean;
-/**
- * Convert string paths to FileItem objects
- */
-export declare const convertToFileItems: (paths: string[]) => FileItem[];
-/**
- * Search files and directories using glob patterns
- */
-export declare const searchFiles: (query: string, options?: {
-    maxResults?: number;
-    workingDirectory?: string;
-}) => Promise<FileItem[]>;
-//# sourceMappingURL=fileSearch.d.ts.map

package/dist/utils/fileSearch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fileSearch.d.ts","sourceRoot":"","sources":["../../src/utils/fileSearch.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CAC5B;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,MAAM,KAAG,OAS9C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,EAAE,KAAG,QAAQ,EAK5D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,EACb,UAAU;IACR,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,KACA,OAAO,CAAC,QAAQ,EAAE,CAyFpB,CAAC"}

package/dist/utils/fileSearch.js

@@ -1,102 +0,0 @@
-import { glob } from "glob";
-import { getGlobIgnorePatterns } from "wave-agent-sdk";
-import * as fs from "fs";
-import * as path from "path";
-/**
- * Check if path is a directory
- */
-export const isDirectory = (filePath) => {
-    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) => {
-    return paths.map((filePath) => ({
-        path: filePath,
-        type: isDirectory(filePath) ? "directory" : "file",
-    }));
-};
-/**
- * Search files and directories using glob patterns
- */
-export const searchFiles = async (query, options) => {
-    const { maxResults = 10, workingDirectory = process.cwd() } = options || {};
-    try {
-        let files = [];
-        let directories = [];
-        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 [];
-    }
-};