clawmate 1.4.0 → 1.4.2

package/main/ipc-handlers.js

@@ -18,7 +18,7 @@ const memoryStore = new Store('clawmate-memory', {
 });
 
 function registerIpcHandlers(getMainWindow, getAIBridge) {
-  // 클릭 통과 제어
+  // Click-through control
   ipcMain.on('set-click-through', (event, ignore) => {
     const win = getMainWindow();
     if (win) {
@@ -26,14 +26,14 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     }
   });
 
-  // 파일 작업
+  // File operations
   ipcMain.handle('get-desktop-files', async () => getDesktopFiles());
   ipcMain.handle('move-file', async (_, fileName, newPos) => moveFile(fileName, newPos));
   ipcMain.handle('undo-file-move', async (_, moveId) => undoFileMove(moveId));
   ipcMain.handle('undo-all-moves', async () => undoAllMoves());
   ipcMain.handle('get-file-manifest', async () => getFileManifest());
 
-  // 모드
+  // Mode
   ipcMain.handle('get-mode', () => store.get('mode'));
   ipcMain.handle('set-mode', (_, mode) => {
     store.set('mode', mode);
@@ -42,7 +42,7 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     return mode;
   });
 
-  // 설정
+  // Config
   ipcMain.handle('get-config', () => store.getAll());
   ipcMain.handle('set-config', (_, key, value) => {
     store.set(key, value);
@@ -51,20 +51,20 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     return true;
   });
 
-  // 메모리
+  // Memory
   ipcMain.handle('get-memory', () => memoryStore.getAll());
   ipcMain.handle('save-memory', (_, data) => {
     Object.entries(data).forEach(([key, value]) => memoryStore.set(key, value));
     return true;
   });
 
-  // 화면 크기
+  // Screen size
   ipcMain.handle('get-screen-size', () => {
     const { width, height } = screen.getPrimaryDisplay().workAreaSize;
     return { width, height };
   });
 
-  // 화면 캡처
+  // Screen capture
   ipcMain.handle('capture-screen', async () => {
     try {
       const primaryDisplay = screen.getPrimaryDisplay();
@@ -76,7 +76,7 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
       });
 
       if (sources.length > 0) {
-        // NativeImage를 base64 JPEG로 변환 (크기 최적화)
+        // Convert NativeImage to base64 JPEG (size optimized)
         const thumbnail = sources[0].thumbnail;
         const jpegBuffer = thumbnail.toJPEG(60);
         return {
@@ -93,9 +93,9 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     }
   });
 
-  // === AI 통신 ===
+  // === AI Communication ===
 
-  // 사용자 이벤트를 AI Bridge로 전달 (렌더러 → main → AI)
+  // Forward user events to AI Bridge (renderer -> main -> AI)
   ipcMain.on('report-to-ai', (_, event, data) => {
     const bridge = getAIBridge();
     if (bridge && bridge.isConnected()) {
@@ -125,24 +125,24 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
           bridge.reportIdleTime(data.idleSeconds);
           break;
         case 'browsing':
-          // 브라우징 컨텍스트 (제목 + 커서 위치 + 화면 캡처) → AI 코멘트 생성
+          // Browsing context (title + cursor position + screen capture) -> AI comment generation
           bridge.send('user_event', { event: 'browsing', ...data });
           break;
         default:
-          // 알 수 없는 이벤트도 AI에 전달 (확장성)
+          // Forward unknown events to AI as well (extensibility)
           bridge.send('user_event', { event, ...data });
           break;
       }
     }
   });
 
-  // AI 연결 상태 확인
+  // Check AI connection status
   ipcMain.handle('is-ai-connected', () => {
     const bridge = getAIBridge();
     return bridge ? bridge.isConnected() : false;
   });
 
-  // 메트릭 보고 (렌더러 → main → AI)
+  // Metrics reporting (renderer -> main -> AI)
   ipcMain.on('report-metrics', (_, summary) => {
     const bridge = getAIBridge();
     if (bridge && bridge.isConnected()) {
@@ -150,38 +150,38 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     }
   });
 
-  // 열린 윈도우 위치/크기 조회
+  // Get open window positions/sizes
   ipcMain.handle('get-window-positions', async () => {
     const { getWindowPositions } = require('./platform');
     return await getWindowPositions();
   });
 
-  // 활성 윈도우 제목 조회 (브라우저 감시용)
+  // Get active window title (for browser monitoring)
   ipcMain.handle('get-active-window-title', async () => {
     const { getActiveWindowTitle } = require('./platform');
     return await getActiveWindowTitle();
   });
 
-  // 커서 위치 조회 (화면 좌표)
+  // Get cursor position (screen coordinates)
   ipcMain.handle('get-cursor-position', () => {
     const point = screen.getCursorScreenPoint();
     return { x: point.x, y: point.y };
   });
 
-  // === 스마트 파일 조작 IPC ===
+  // === Smart File Operation IPC ===
 
-  // 파일 명령 파싱 (렌더러에서도 사용 가능)
+  // Parse file command (also available from renderer)
   ipcMain.handle('parse-file-command', (_, text) => {
     return parseMessage(text);
   });
 
-  // 필터된 파일 목록 조회
+  // Get filtered file list
   ipcMain.handle('list-filtered-files', async (_, sourceDir, filter) => {
     return listFilteredFiles(sourceDir, filter);
   });
 
-  // 스마트 파일 조작 실행
-  // 렌더러에서 직접 실행할 때 사용 (텔레그램 경유가 아닌 경우)
+  // Execute smart file operation
+  // Used when executed directly from renderer (not via Telegram)
   ipcMain.handle('smart-file-op', async (_, command) => {
     const win = getMainWindow();
     const callbacks = {
@@ -230,12 +230,12 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     return await executeSmartFileOp(command, callbacks);
   });
 
-  // 스마트 이동 되돌리기 (단일)
+  // Undo smart move (single)
   ipcMain.handle('undo-smart-move', async (_, moveId) => {
     return undoSmartMove(moveId);
   });
 
-  // 스마트 이동 전체 되돌리기
+  // Undo all smart moves
   ipcMain.handle('undo-all-smart-moves', async () => {
     return undoAllSmartMoves();
   });

package/main/manifest.js

@@ -3,8 +3,8 @@ const path = require('path');
 const { app } = require('electron');
 
 /**
- * 파일 이동 이력 관리 (Undo 지원)
- * 모든 파일 이동을 기록하고, 복원 가능하게 관리
+ * File move history management (Undo support)
+ * Records all file moves and manages restoration
  */
 const MANIFEST_FILE = () => path.join(app.getPath('userData'), 'file-manifest.json');
 

package/main/platform.js

@@ -47,9 +47,9 @@ function isLinux() {
 }
 
 /**
- * OS별 열린 윈도우의 위치/크기 정보를 가져옴
- * 반환 형식: [{ id, title, x, y, width, height }]
- * 실패 시 빈 배열 반환 (안전한 폴백)
+ * Get position/size info of open windows per OS
+ * Return format: [{ id, title, x, y, width, height }]
+ * Returns empty array on failure (safe fallback)
  */
 async function getWindowPositions() {
   if (platform === 'win32') {
@@ -62,12 +62,12 @@ async function getWindowPositions() {
 }
 
 /**
- * Windows: PowerShell로 보이는 윈도우 목록 + 위치/크기 조회
- * Add-Type으로 Win32 API(GetWindowRect) 호출
+ * Windows: Get visible window list + position/size via PowerShell
+ * Calls Win32 API (GetWindowRect) via Add-Type
  */
 async function getWindowPositionsWindows() {
   try {
-    // PowerShell에서 C# 인라인 컴파일로 Win32 API 접근
+    // Access Win32 API via inline C# compilation in PowerShell
     const psScript = `
 Add-Type @"
 using System;
@@ -101,7 +101,7 @@ public class WinInfo {
 [WinInfo]::GetWindows()
 `.trim();
 
-    // PowerShell 스크립트를 임시 파일 없이 stdin으로 전달
+    // Pass PowerShell script via stdin without temp files
     const { stdout } = await execAsync(
       `powershell -NoProfile -Command -`,
       { input: psScript, timeout: 5000, encoding: 'utf-8' }
@@ -129,11 +129,11 @@ public class WinInfo {
 }
 
 /**
- * macOS: AppleScript로 보이는 윈도우 위치/크기 조회
+ * macOS: Get visible window positions/sizes via AppleScript
  */
 async function getWindowPositionsMac() {
   try {
-    // AppleScript로 보이는 프로세스의 윈도우 정보 수집
+    // Collect window info of visible processes via AppleScript
     const script = `
 tell application "System Events"
   set output to ""
@@ -180,8 +180,8 @@ end tell
 }
 
 /**
- * Linux: wmctrl -l -G 로 윈도우 위치/크기 조회
- * wmctrl 미설치 시 빈 배열 반환
+ * Linux: Get window positions/sizes via wmctrl -l -G
+ * Returns empty array if wmctrl is not installed
  */
 async function getWindowPositionsLinux() {
   try {
@@ -193,8 +193,8 @@ async function getWindowPositionsLinux() {
     const result = (stdout || '').trim();
     if (!result) return [];
 
-    // wmctrl -l -G 출력 형식:
-    // 0x02000003  0 0    0    1920 1080 hostname 데스크톱
+    // wmctrl -l -G output format:
+    // 0x02000003  0 0    0    1920 1080 hostname Desktop
     // ID          desktop x  y  width height hostname title
     return result.split('\n').filter(Boolean).map((line, i) => {
       const parts = line.trim().split(/\s+/);
@@ -203,7 +203,7 @@ async function getWindowPositionsLinux() {
       const y = parseInt(parts[3], 10) || 0;
       const width = parseInt(parts[4], 10) || 0;
       const height = parseInt(parts[5], 10) || 0;
-      // hostname 이후가 타이틀 (공백 포함 가능)
+      // Everything after hostname is the title (may contain spaces)
       const title = parts.slice(7).join(' ');
       if (width < 50 || height < 50) return null;
       return { id: `win_${i}`, title, x, y, width, height };
@@ -214,8 +214,8 @@ async function getWindowPositionsLinux() {
 }
 
 /**
- * 현재 포커스된 (최상위) 윈도우의 제목 반환
- * 브라우저 탭 제목을 감지하여 펫이 참견할 수 있게 함
+ * Return title of currently focused (foreground) window
+ * Detects browser tab titles so the pet can comment on them
  */
 async function getActiveWindowTitle() {
   try {

package/main/smart-file-ops.js

@@ -1,15 +1,15 @@
 /**
- * 스마트 파일 조작 시스템
+ * Smart File Operation System
  *
- * 텔레그램 또는 AI 명령으로 파일을 "펫이 직접 나르는" 방식으로 이동.
- * 펫이 파일 위치로 점프 → 집어들기 → 대상 폴더로 이동 → 내려놓기 순서로
- * 애니메이션과 실제 파일시스템 이동을 동시에 수행.
+ * Moves files via Telegram or AI commands in a "pet carries them" fashion.
+ * Pet jumps to file location -> picks up -> moves to target folder -> drops off,
+ * performing animation and actual filesystem move simultaneously.
  *
- * 안전장치:
- *   - .exe/.dll/.sys 등 위험 확장자 제외
- *   - 100MB 이상 파일 제외
- *   - 모든 이동을 manifest에 기록 (undo 가능)
- *   - 진행 중 중단 시 이미 이동된 파일은 manifest에 기록되어 복원 가능
+ * Safety measures:
+ *   - Excludes dangerous extensions like .exe/.dll/.sys
+ *   - Excludes files over 100MB
+ *   - Records all moves in manifest (undo supported)
+ *   - Files already moved during interruption are recorded in manifest for restoration
  */
 
 const fs = require('fs');
@@ -18,46 +18,46 @@ const { getDesktopPath } = require('./desktop-path');
 const manifest = require('./manifest');
 const { AUTO_CATEGORIES } = require('./file-command-parser');
 
-// 안전장치 상수
+// Safety constants
 const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
 const EXCLUDED_EXTS = new Set([
   '.exe', '.dll', '.sys', '.lnk', '.ini', '.bat', '.cmd',
   '.ps1', '.msi', '.scr', '.com', '.pif', '.vbs', '.wsf',
 ]);
 
-// 파일 이동 간 딜레이 (ms) - 펫 애니메이션에 시간을 줌
+// Delay between file moves (ms) - gives time for pet animation
 const PER_FILE_DELAY = 2500;
 
 /**
- * 파일이 이동 가능한지 검증
- * @param {string} filePath - 파일 전체 경로
+ * Validate whether file can be moved
+ * @param {string} filePath - Full file path
  * @returns {{ safe: boolean, reason?: string }}
  */
 function validateFile(filePath) {
   const ext = path.extname(filePath).toLowerCase();
   if (EXCLUDED_EXTS.has(ext)) {
-    return { safe: false, reason: `보호된 파일 유형 (${ext})` };
+    return { safe: false, reason: `Protected file type (${ext})` };
   }
 
   try {
     const stat = fs.statSync(filePath);
     if (stat.size > MAX_FILE_SIZE) {
-      return { safe: false, reason: `파일 크기 초과 (${Math.round(stat.size / 1024 / 1024)}MB > 100MB)` };
+      return { safe: false, reason: `File size exceeded (${Math.round(stat.size / 1024 / 1024)}MB > 100MB)` };
     }
     if (!stat.isFile()) {
-      return { safe: false, reason: '파일이 아님' };
+      return { safe: false, reason: 'Not a file' };
     }
   } catch {
-    return { safe: false, reason: '파일 접근 불가' };
+    return { safe: false, reason: 'File inaccessible' };
   }
 
   return { safe: true };
 }
 
 /**
- * 소스 디렉토리에서 필터 조건에 맞는 파일 목록 조회
- * @param {string} sourceDir - 소스 디렉토리 경로
- * @param {string} filter - 확장자 필터 (예: ".md", "*")
+ * List files matching filter criteria in source directory
+ * @param {string} sourceDir - Source directory path
+ * @param {string} filter - Extension filter (e.g., ".md", "*")
  * @returns {Array<{ name: string, path: string, ext: string, size: number }>}
  */
 function listFilteredFiles(sourceDir, filter) {
@@ -72,10 +72,10 @@ function listFilteredFiles(sourceDir, filter) {
       const filePath = path.join(sourceDir, entry.name);
       const ext = path.extname(entry.name).toLowerCase();
 
-      // 확장자 필터 적용
+      // Apply extension filter
       if (filter !== '*' && ext !== filter.toLowerCase()) continue;
 
-      // 안전 검증
+      // Safety validation
       const validation = validateFile(filePath);
       if (!validation.safe) continue;
 
@@ -99,16 +99,16 @@ function listFilteredFiles(sourceDir, filter) {
 }
 
 /**
- * 자동 분류 모드: 파일을 확장자별 폴더로 분류
- * @param {string} sourceDir - 소스 디렉토리
- * @returns {Map<string, Array>} 카테고리명 → 파일 목록
+ * Auto-categorize mode: sort files into folders by extension
+ * @param {string} sourceDir - Source directory
+ * @returns {Map<string, Array>} Category name -> file list
  */
 function categorizeFiles(sourceDir) {
   const files = listFilteredFiles(sourceDir, '*');
   const categories = new Map();
 
   for (const file of files) {
-    const category = AUTO_CATEGORIES[file.ext] || '기타';
+    const category = AUTO_CATEGORIES[file.ext] || 'Other';
     if (!categories.has(category)) {
       categories.set(category, []);
     }
@@ -119,10 +119,10 @@ function categorizeFiles(sourceDir) {
 }
 
 /**
- * 대상 폴더 생성 (없으면)
- * @param {string} sourceDir - 소스 디렉토리 (대상 폴더의 부모)
- * @param {string} targetName - 대상 폴더 이름
- * @returns {string} 대상 폴더 전체 경로
+ * Create target folder (if it doesn't exist)
+ * @param {string} sourceDir - Source directory (parent of target folder)
+ * @param {string} targetName - Target folder name
+ * @returns {string} Full path of target folder
  */
 function ensureTargetDir(sourceDir, targetName) {
   const targetDir = path.join(sourceDir, targetName);
@@ -133,16 +133,16 @@ function ensureTargetDir(sourceDir, targetName) {
 }
 
 /**
- * 단일 파일 이동 실행 + manifest 기록
- * @param {string} filePath - 원본 파일 경로
- * @param {string} targetDir - 대상 디렉토리
+ * Execute single file move + record in manifest
+ * @param {string} filePath - Original file path
+ * @param {string} targetDir - Target directory
  * @returns {{ success: boolean, newPath?: string, error?: string, moveId?: string }}
  */
 function moveFileToTarget(filePath, targetDir) {
   const fileName = path.basename(filePath);
   let newPath = path.join(targetDir, fileName);
 
-  // 동일 이름 파일이 있으면 넘버링
+  // Number files if same name exists
   if (fs.existsSync(newPath)) {
     const ext = path.extname(fileName);
     const base = path.basename(fileName, ext);
@@ -156,7 +156,7 @@ function moveFileToTarget(filePath, targetDir) {
   try {
     fs.renameSync(filePath, newPath);
 
-    // manifest에 기록 (undo 지원)
+    // Record in manifest (undo support)
     const entry = manifest.addEntry({
       fileName,
       originalPath: filePath,
@@ -172,39 +172,39 @@ function moveFileToTarget(filePath, targetDir) {
 }
 
 /**
- * 스마트 파일 이동 되돌리기 (단일)
- * @param {string} moveId - manifest 엔트리 ID
+ * Undo smart file move (single)
+ * @param {string} moveId - Manifest entry ID
  * @returns {{ success: boolean, error?: string }}
  */
 function undoSmartMove(moveId) {
   const entries = manifest.getAll();
   const entry = entries.find(e => e.id === moveId && e.action === 'smart_move');
   if (!entry) {
-    return { success: false, error: '이동 기록을 찾을 수 없음' };
+    return { success: false, error: 'Move record not found' };
   }
   if (entry.restored) {
-    return { success: false, error: '이미 복원된 항목' };
+    return { success: false, error: 'Already restored' };
   }
 
   try {
-    // 새 위치에서 원래 위치로 되돌리기
+    // Restore from new location to original location
     if (fs.existsSync(entry.newPath)) {
-      // 원래 위치에 같은 이름 파일이 있으면 충돌 방지
+      // Prevent conflict if same name file exists at original location
       if (fs.existsSync(entry.originalPath)) {
-        return { success: false, error: '원래 위치에 동일 이름 파일이 존재' };
+        return { success: false, error: 'File with same name exists at original location' };
       }
       fs.renameSync(entry.newPath, entry.originalPath);
       manifest.markRestored(moveId);
       return { success: true };
     }
-    return { success: false, error: '이동된 파일을 찾을 수 없음' };
+    return { success: false, error: 'Moved file not found' };
   } catch (err) {
     return { success: false, error: err.message };
   }
 }
 
 /**
- * 스마트 파일 이동 전체 되돌리기
+ * Undo all smart file moves
  * @returns {{ success: boolean, restoredCount: number, errors: string[] }}
  */
 function undoAllSmartMoves() {
@@ -213,7 +213,7 @@ function undoAllSmartMoves() {
   let restoredCount = 0;
   const errors = [];
 
-  // 최신 이동부터 역순으로 복원
+  // Restore in reverse order starting from most recent
   for (const entry of smartMoves.reverse()) {
     const result = undoSmartMove(entry.id);
     if (result.success) {
@@ -227,33 +227,33 @@ function undoAllSmartMoves() {
 }
 
 /**
- * 스마트 파일 조작 실행 (전체 흐름)
+ * Execute smart file operation (full flow)
  *
- * 콜백 함수를 통해 펫 애니메이션을 제어하면서 파일을 순차적으로 이동.
+ * Sequentially moves files while controlling pet animation via callbacks.
  *
- * @param {object} command - 파싱된 파일 명령
- *   - source: 소스 디렉토리 경로
- *   - filter: 확장자 필터 (예: ".md", "*")
- *   - target: 대상 폴더 이름 또는 "auto"
- *   - autoCategory: 자동 분류 여부
- * @param {object} callbacks - 펫 애니메이션 콜백
- *   - onStart(totalFiles): 작업 시작 시
- *   - onPickUp(fileName, index): 파일 집어들 때
- *   - onDrop(fileName, targetName, index): 파일 내려놓을 때
- *   - onComplete(result): 작업 완료 시
- *   - onError(error): 오류 발생 시
+ * @param {object} command - Parsed file command
+ *   - source: Source directory path
+ *   - filter: Extension filter (e.g., ".md", "*")
+ *   - target: Target folder name or "auto"
+ *   - autoCategory: Whether to auto-categorize
+ * @param {object} callbacks - Pet animation callbacks
+ *   - onStart(totalFiles): When operation starts
+ *   - onPickUp(fileName, index): When picking up file
+ *   - onDrop(fileName, targetName, index): When dropping file
+ *   - onComplete(result): When operation completes
+ *   - onError(error): When error occurs
  * @returns {Promise<{ success: boolean, movedCount: number, errors: string[], moveIds: string[] }>}
  */
 async function executeSmartFileOp(command, callbacks = {}) {
   const { source, filter, target, autoCategory } = command;
 
   try {
-    // 자동 분류 모드
+    // Auto-categorize mode
     if (autoCategory) {
       return await _executeAutoCategory(source, callbacks);
     }
 
-    // 특정 대상 폴더로 이동
+    // Move to specific target folder
     return await _executeTargetMove(source, filter, target, callbacks);
   } catch (err) {
     if (callbacks.onError) callbacks.onError(err.message);
@@ -262,7 +262,7 @@ async function executeSmartFileOp(command, callbacks = {}) {
 }
 
 /**
- * 자동 분류 실행
+ * Execute auto-categorization
  */
 async function _executeAutoCategory(sourceDir, callbacks) {
   const categories = categorizeFiles(sourceDir);
@@ -286,8 +286,8 @@ async function _executeAutoCategory(sourceDir, callbacks) {
   let fileIndex = 0;
 
   for (const [category, files] of categories) {
-    // "기타" 카테고리에 파일이 적으면 건너뜀
-    if (category === '기타' && files.length <= 2) continue;
+    // Skip "Other" category if few files
+    if (category === 'Other' && files.length <= 2) continue;
 
     const targetDir = ensureTargetDir(sourceDir, category);
 
@@ -315,7 +315,7 @@ async function _executeAutoCategory(sourceDir, callbacks) {
 }
 
 /**
- * 특정 대상 폴더로 이동 실행
+ * Execute move to specific target folder
  */
 async function _executeTargetMove(sourceDir, filter, targetName, callbacks) {
   const files = listFilteredFiles(sourceDir, filter);

package/main/store.js

@@ -15,7 +15,7 @@ class Store {
       const raw = fs.readFileSync(this.path, 'utf-8');
       this.data = { ...this.data, ...JSON.parse(raw) };
     } catch {
-      // 파일 없으면 기본값 사용
+      // Use defaults if file doesn't exist
     }
   }