feat: Add EditAction component and FileEditor class

- Create EditAction component for displaying file edit diffs
- Add FileEditor class for cat-like file editing functionality
- Implement structured diff generation with Diff[] format
- Support git-tracked file selection with fallback to glob search
- Add random cat word replacement (up to 3 replacements)
- Use ANSI256 colors for optimal diff background visibility

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: koki-develop

src/components/EditAction.tsx

@@ -0,0 +1,53 @@
+import chalk from "chalk";
+import { Box, Text } from "ink";
+import type React from "react";
+import type { EditAction as EditActionType } from "./types";
+
+interface EditActionProps {
+  action: EditActionType;
+}
+
+const formatDiffs = (diffs: EditActionType["diff"]["diffs"]): string => {
+  const lines: string[] = [];
+
+  for (let i = 0; i < diffs.length; i++) {
+    const diff = diffs[i];
+    const nextDiff = diffs[i + 1];
+
+    if (!diff) continue;
+
+    // Deleted line
+    if (diff.a !== "") {
+      lines.push(
+        `${chalk.gray(diff.rowNumber)} ${chalk.bgAnsi256(52)(`- ${diff.a}`)}`,
+      );
+    }
+    // Added line
+    if (diff.b !== "") {
+      lines.push(
+        `${chalk.gray(diff.rowNumber)} ${chalk.bgAnsi256(22)(`+ ${diff.b}`)}`,
+      );
+    }
+
+    // Add empty line if next diff exists and line numbers are not consecutive
+    if (nextDiff && nextDiff.rowNumber !== diff.rowNumber + 1) {
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+};
+
+export const EditAction: React.FC<EditActionProps> = ({ action }) => {
+  return (
+    <Box flexDirection="column">
+      <Text>
+        <Text color="green">⏺</Text> <Text bold>Update</Text>(
+        {action.diff.fileName})
+      </Text>
+      <Box paddingLeft={2} paddingY={1}>
+        <Text>{formatDiffs(action.diff.diffs)}</Text>
+      </Box>
+    </Box>
+  );
+};

src/lib/fileEditor.ts

@@ -0,0 +1,184 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { glob } from "glob";
+import type { Diff, FileDiff } from "../components/types";
+import { Git } from "./git";
+
+export class FileEditor {
+  private git = new Git();
+  // Text file extension patterns
+  // TODO: enhance these patterns
+  private readonly textFilePatterns = [
+    "**/*.txt",
+    "**/*.md",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.json",
+    "**/*.css",
+    "**/*.html",
+    "**/*.xml",
+    "**/*.yml",
+    "**/*.yaml",
+  ];
+
+  // Cat word candidates
+  private readonly catWords = [
+    "ﾆｬｰ",
+    "ﾐｬｰ",
+    "ﾆｬﾝ",
+    "ﾐｬﾝ",
+    "ﾆｬｯ",
+    "ﾐｬｯ",
+    "ﾆｬｵ~ﾝ",
+    "ﾐｬｵ~",
+    "ｺﾞﾛｺﾞﾛ",
+  ];
+
+  /**
+   * Get files under git management (when git is initialized)
+   */
+  private async getGitTrackedFiles(): Promise<string[]> {
+    const gitFiles = await this.git.lsFiles();
+    return gitFiles.filter((file) => this.isTextFile(file));
+  }
+
+  /**
+   * Search for text files (fallback when git is not initialized)
+   */
+  private async getTextFiles(): Promise<string[]> {
+    return await glob(this.textFilePatterns);
+  }
+
+  /**
+   * Determine if a file is a text file
+   */
+  private isTextFile(filePath: string): boolean {
+    const extension = filePath.split(".").pop()?.toLowerCase();
+    const textExtensions = [
+      "txt",
+      "md",
+      "js",
+      "ts",
+      "tsx",
+      "json",
+      "css",
+      "html",
+      "xml",
+      "yml",
+      "yaml",
+    ];
+    return textExtensions.includes(extension || "");
+  }
+
+  /**
+   * Select a file randomly
+   */
+  async selectRandomFile(): Promise<string | null> {
+    let files: string[];
+
+    // Check if git is initialized
+    if (await this.git.isInited()) {
+      files = await this.getGitTrackedFiles();
+    } else {
+      files = await this.getTextFiles();
+    }
+
+    if (files.length === 0) {
+      return null;
+    }
+
+    const randomIndex = Math.floor(Math.random() * files.length);
+    return files[randomIndex] as string;
+  }
+
+  /**
+   * Edit file content in a cat-like manner
+   */
+  private editFileContent(content: string): string {
+    const words = content.match(/\w+/g);
+    if (!words || words.length === 0) return content;
+
+    const targetWord = words[
+      Math.floor(Math.random() * words.length)
+    ] as string;
+    const catWord = this.catWords[
+      Math.floor(Math.random() * this.catWords.length)
+    ] as string;
+
+    // Replace up to 3 locations
+    let replacedContent = content;
+    let replacementCount = 0;
+    const maxReplacements = 3;
+
+    replacedContent = replacedContent.replace(
+      new RegExp(`\\b${targetWord}\\b`, "g"),
+      (match) => {
+        if (replacementCount < maxReplacements) {
+          replacementCount++;
+          return catWord;
+        }
+        return match;
+      },
+    );
+
+    return replacedContent;
+  }
+
+  /**
+   * Generate structured diff
+   */
+  private generateDiffs(original: string, edited: string): Diff[] {
+    const originalLines = original.split("\n");
+    const editedLines = edited.split("\n");
+    const diffs: Diff[] = [];
+
+    const maxLines = Math.max(originalLines.length, editedLines.length);
+
+    for (let i = 0; i < maxLines; i++) {
+      const rowNumber = i + 1;
+      const originalLine = originalLines[i] || "";
+      const editedLine = editedLines[i] || "";
+
+      if (originalLine !== editedLine) {
+        diffs.push({
+          rowNumber,
+          a: originalLine,
+          b: editedLine,
+        });
+      }
+    }
+
+    return diffs;
+  }
+
+  /**
+   * Edit file and generate diff
+   */
+  async edit(): Promise<FileDiff | null> {
+    const filePath = await this.selectRandomFile();
+    if (!filePath) {
+      return null;
+    }
+
+    // Read file content
+    const originalContent = await readFile(filePath, "utf-8");
+
+    // Edit
+    const editedContent = this.editFileContent(originalContent);
+
+    // Write to file
+    await writeFile(filePath, editedContent, "utf-8");
+
+    // Generate structured diff
+    const diffs = this.generateDiffs(originalContent, editedContent);
+    if (diffs.length === 0) {
+      return null;
+    }
+
+    return {
+      fileName: filePath,
+      diffs,
+    };
+  }
+}