wave-code 0.0.6 → 0.0.8

package/src/components/DiffViewer.tsx

@@ -1,323 +0,0 @@
-import React, { useMemo } from "react";
-import { Text, Box } from "ink";
-import { diffWords } from "diff";
-import type { DiffBlock } from "wave-agent-sdk";
-
-interface DiffViewerProps {
-  block: DiffBlock;
-  isStatic?: boolean;
-}
-
-// Render word-level diff
-const renderWordLevelDiff = (removedLine: string, addedLine: string) => {
-  const changes = diffWords(removedLine, addedLine);
-
-  const removedParts: React.ReactNode[] = [];
-  const addedParts: React.ReactNode[] = [];
-
-  changes.forEach((part, index) => {
-    if (part.removed) {
-      removedParts.push(
-        <Text key={`removed-${index}`} color="black" backgroundColor="red">
-          {part.value}
-        </Text>,
-      );
-    } else if (part.added) {
-      addedParts.push(
-        <Text key={`added-${index}`} color="black" backgroundColor="green">
-          {part.value}
-        </Text>,
-      );
-    } else {
-      // Unchanged parts, need to display on both sides
-      removedParts.push(
-        <Text key={`removed-unchanged-${index}`} color="red">
-          {part.value}
-        </Text>,
-      );
-      addedParts.push(
-        <Text key={`added-unchanged-${index}`} color="green">
-          {part.value}
-        </Text>,
-      );
-    }
-  });
-
-  return { removedParts, addedParts };
-};
-
-export const DiffViewer: React.FC<DiffViewerProps> = ({
-  block,
-  isStatic = true,
-}) => {
-  const { diffResult } = block;
-
-  const diffLines = useMemo(() => {
-    if (!diffResult) return [];
-
-    const lines: Array<{
-      content: string;
-      type: "added" | "removed" | "unchanged" | "separator";
-      lineNumber?: number;
-      rawContent?: string; // Store original content for word-level comparison
-      wordDiff?: {
-        removedParts: React.ReactNode[];
-        addedParts: React.ReactNode[];
-      };
-    }> = [];
-
-    let originalLineNum = 1;
-    let modifiedLineNum = 1;
-    const maxContext = 3; // Show at most 3 lines of context
-
-    // Buffer for storing context
-    let contextBuffer: Array<{
-      content: string;
-      type: "unchanged";
-      lineNumber: number;
-    }> = [];
-
-    let hasAnyChanges = false;
-    let afterChangeContext = 0;
-
-    // Temporarily store adjacent deleted and added lines for word-level comparison
-    let pendingRemovedLines: Array<{
-      content: string;
-      rawContent: string;
-      lineNumber: number;
-    }> = [];
-
-    const flushPendingLines = () => {
-      pendingRemovedLines.forEach((line) => {
-        lines.push({
-          content: line.content,
-          type: "removed",
-          lineNumber: line.lineNumber,
-          rawContent: line.rawContent,
-        });
-      });
-      pendingRemovedLines = [];
-    };
-
-    diffResult.forEach(
-      (part: { value: string; added?: boolean; removed?: boolean }) => {
-        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: string) => {
-            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: string, index: number) => {
-            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: string) => {
-            const contextLine = {
-              content: `  ${line}`,
-              type: "unchanged" as const,
-              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 (
-      <Box flexDirection="column">
-        <Text color="gray">No changes detected</Text>
-      </Box>
-    );
-  }
-
-  // Show traditional diff view
-  return (
-    <Box flexDirection="column">
-      <Box flexDirection="column">
-        <Box flexDirection="column">
-          {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 (
-                <Box key={index} flexDirection="row">
-                  <Text color={line.type === "removed" ? "red" : "green"}>
-                    {prefix}
-                  </Text>
-                  <Box flexDirection="row" flexWrap="wrap">
-                    {parts}
-                  </Box>
-                </Box>
-              );
-            }
-
-            // Normal rendering
-            return (
-              <Text
-                key={index}
-                color={
-                  line.type === "added"
-                    ? "green"
-                    : line.type === "removed"
-                      ? "red"
-                      : line.type === "separator"
-                        ? "gray"
-                        : "white"
-                }
-                dimColor={line.type === "separator"}
-              >
-                {line.content}
-              </Text>
-            );
-          })}
-        </Box>
-      </Box>
-    </Box>
-  );
-};

package/src/utils/fileSearch.ts

@@ -1,133 +0,0 @@
-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 [];
-  }
-};