clawmate 1.2.0 → 1.3.0

package/main/ai-bridge.js

@@ -133,6 +133,12 @@ class AIBridge extends EventEmitter {
         this.emit('drop_file', payload);
         break;
 
+      case 'smart_file_op':
+        // 스마트 파일 조작 (텔레그램 또는 AI에서 트리거)
+        // payload: { phase: 'pick_up'|'drop'|'complete', fileName?, targetName?, ... }
+        this.emit('smart_file_op', payload);
+        break;
+
       // === 외형 변화 ===
       case 'evolve':
         // 진화 트리거
@@ -188,6 +194,43 @@ class AIBridge extends EventEmitter {
         this.emit('query_windows', payload);
         break;
 
+      // === 커스텀 이동 패턴 ===
+      case 'register_movement':
+        // OpenClaw이 커스텀 이동 패턴 등록
+        // payload: { name: string, definition: { type: 'waypoints'|'formula'|'sequence', ... } }
+        this.emit('register_movement', payload);
+        break;
+
+      case 'custom_move':
+        // 등록된 커스텀 이동 패턴 실행
+        // payload: { name: string, params?: object }
+        this.emit('custom_move', payload);
+        break;
+
+      case 'stop_custom_move':
+        // 현재 커스텀 이동 강제 중지
+        // payload: {}
+        this.emit('stop_custom_move', payload);
+        break;
+
+      case 'list_movements':
+        // 등록된 이동 패턴 목록 요청 → 응답은 renderer에서 reportToAI로 전송
+        // payload: {}
+        this.emit('list_movements', payload);
+        break;
+
+      // === 캐릭터 커스터마이징 ===
+      case 'set_character':
+        // AI가 생성한 캐릭터 데이터 적용
+        // payload: { colorMap?: {...}, frames?: {...} }
+        this.emit('set_character', payload);
+        break;
+
+      case 'reset_character':
+        // 원래 캐릭터로 리셋
+        this.emit('reset_character', payload);
+        break;
+
       // === 컨텍스트 질의 ===
       case 'query_state':
         // 현재 펫 상태 요청
@@ -285,6 +328,17 @@ class AIBridge extends EventEmitter {
     });
   }
 
+  /**
+   * 메트릭 데이터를 OpenClaw에 전송
+   * 렌더러에서 수집한 펫 동작 품질 메트릭을 AI에 전달
+   */
+  reportMetrics(summary) {
+    this.send('metrics_report', {
+      metrics: summary,
+      timestamp: Date.now(),
+    });
+  }
+
   // === 상태 업데이트 ===
 
   updatePetState(updates) {

package/main/ai-connector.js

@@ -95,6 +95,11 @@ class OpenClawConnector extends EventEmitter {
         this.emit('window_positions', payload);
         break;
 
+      case 'metrics_report':
+        // 메트릭 데이터 수신 → OpenClaw AI가 분석
+        this.emit('metrics_report', payload);
+        break;
+
       case 'heartbeat':
         break;
     }
@@ -197,6 +202,74 @@ class OpenClawConnector extends EventEmitter {
     return this._send('query_windows', {});
   }
 
+  // === 커스텀 이동 패턴 API ===
+
+  /**
+   * 커스텀 이동 패턴 등록
+   * ClawMate에 새로운 이동 패턴을 동적으로 추가
+   *
+   * @param {string} name - 패턴 이름 (예: 'figure8', 'spiral')
+   * @param {object} definition - 패턴 정의
+   *   type: 'waypoints' | 'formula' | 'sequence'
+   *   waypoints?: [{x, y, pause?}]      — 웨이포인트 순차 이동
+   *   formula?: { xAmp, yAmp, xFreq, yFreq, xPhase, yPhase }  — 수학 궤도
+   *   sequence?: ['zigzag', 'shake']     — 기존 패턴 순차 실행
+   *   duration?: number                  — 지속 시간 (ms, formula 타입)
+   *   speed?: number                     — 이동 속도
+   *
+   * 사용 예:
+   *   connector.registerMovement('figure8', {
+   *     type: 'formula',
+   *     formula: { xAmp: 80, yAmp: 40, xFreq: 1, yFreq: 2 },
+   *     duration: 4000,
+   *   });
+   */
+  registerMovement(name, definition) {
+    return this._send('register_movement', { name, definition });
+  }
+
+  /**
+   * 등록된 커스텀 이동 패턴 실행
+   *
+   * @param {string} name - 실행할 패턴 이름
+   *   사전 등록 패턴: 'zigzag', 'patrol', 'circle', 'shake', 'dance'
+   *   또는 registerMovement()로 등록한 커스텀 패턴
+   * @param {object} params - 실행 파라미터 (패턴별로 다름)
+   *
+   * 사용 예:
+   *   connector.customMove('zigzag', { distance: 200, amplitude: 30 });
+   *   connector.customMove('patrol', { pointAX: 100, pointBX: 500, laps: 5 });
+   *   connector.customMove('shake', { intensity: 6, duration: 1000 });
+   */
+  customMove(name, params = {}) {
+    return this._send('custom_move', { name, params });
+  }
+
+  /** 현재 실행 중인 커스텀 이동 강제 중지 */
+  stopCustomMove() {
+    return this._send('stop_custom_move', {});
+  }
+
+  /** 등록된 이동 패턴 목록 요청 (응답은 user_event로 수신) */
+  listMovements() {
+    return this._send('list_movements', {});
+  }
+
+  /** 스마트 파일 조작 명령 전송 */
+  smartFileOp(payload) {
+    return this._send('smart_file_op', payload);
+  }
+
+  /** 캐릭터 데이터 전송 (AI 생성 캐릭터 적용) */
+  setCharacter(data) {
+    return this._send('set_character', data);
+  }
+
+  /** 원래 캐릭터로 리셋 */
+  resetCharacter() {
+    return this._send('reset_character', {});
+  }
+
   /**
    * 현재 펫 상태 요청 (Promise 반환)
    * 서버에서 state_response가 오면 resolve, 타임아웃 시 캐시된 상태 반환
@@ -234,6 +307,11 @@ class OpenClawConnector extends EventEmitter {
     this.on('user_event', callback);
   }
 
+  /** 메트릭 리포트 리스너 등록 */
+  onMetrics(callback) {
+    this.on('metrics_report', callback);
+  }
+
   disconnect() {
     this._autoReconnect = false;
     if (this._reconnectTimer) clearTimeout(this._reconnectTimer);

package/main/file-command-parser.js

@@ -0,0 +1,324 @@
+/**
+ * 파일 조작 명령 파서
+ *
+ * 한국어/영어 자연어를 파싱하여 파일 조작 의도를 추출한다.
+ * 텔레그램 메시지에서 파일 이동, 정리 등의 명령을 감지.
+ *
+ * 지원 패턴:
+ *   - "바탕화면의 .md 파일을 tata 폴더에 넣어줘"
+ *   - "스크린샷 폴더에 .png 정리해"
+ *   - "바탕화면 정리해"
+ *   - "move .txt files to docs folder"
+ */
+
+const os = require('os');
+const path = require('path');
+
+// 알려진 소스 경로 별칭 (한국어 + 영어)
+const SOURCE_ALIASES = {
+  '바탕화면': () => _getDesktopPath(),
+  '데스크탑': () => _getDesktopPath(),
+  '데스크톱': () => _getDesktopPath(),
+  'desktop': () => _getDesktopPath(),
+  '다운로드': () => path.join(os.homedir(), 'Downloads'),
+  '다운': () => path.join(os.homedir(), 'Downloads'),
+  'downloads': () => path.join(os.homedir(), 'Downloads'),
+  '문서': () => path.join(os.homedir(), 'Documents'),
+  'documents': () => path.join(os.homedir(), 'Documents'),
+};
+
+// 행동 명령 키워드 → 액션 매핑
+const ACTION_KEYWORDS = {
+  '점프': 'jumping',
+  '점프해': 'jumping',
+  '뛰어': 'jumping',
+  'jump': 'jumping',
+  '잠자': 'sleeping',
+  '자': 'sleeping',
+  '잠잘래': 'sleeping',
+  'sleep': 'sleeping',
+  '춤춰': 'excited',
+  '춤': 'excited',
+  'dance': 'excited',
+  '걸어': 'walking',
+  '걸어다녀': 'walking',
+  'walk': 'walking',
+  '올라가': 'climbing_up',
+  '기어올라': 'climbing_up',
+  'climb': 'climbing_up',
+  '신나': 'excited',
+  '신나게': 'excited',
+  '놀아': 'playing',
+  '놀자': 'playing',
+  'play': 'playing',
+  '무서워': 'scared',
+  '깜짝': 'scared',
+  '레펠': 'rappelling',
+  '내려와': 'rappelling',
+  'rappel': 'rappelling',
+};
+
+// 파일 조작 감지 키워드
+const FILE_OP_PATTERNS = [
+  // "~의 .ext 파일을 ~폴더에 넣어줘/옮겨줘/이동해"
+  /(?:(.+?)(?:의|에서|에 있는)\s+)?([.\w*]+)\s*파일(?:을|들을)?\s+(.+?)(?:폴더)?(?:에|으로)\s*(?:넣어|옮겨|이동|정리|보내)/,
+  // "~폴더에 .ext 정리해"
+  /(.+?)(?:폴더)?(?:에|으로)\s+([.\w*]+)\s*(?:파일\s*)?(?:정리|넣어|옮겨|이동)/,
+  // "바탕화면 정리해"
+  /(.+?)\s*(?:정리|청소|깔끔하게)\s*(?:해|해줘|하자|좀)/,
+  // 영어: "move .ext files to folder"
+  /move\s+([.\w*]+)\s+files?\s+(?:to|into)\s+(\S+)/i,
+  // 영어: "clean up desktop"
+  /clean\s*(?:up)?\s+(\S+)/i,
+  // 영어: "organize desktop"
+  /organize\s+(\S+)/i,
+];
+
+/**
+ * 데스크톱 경로 가져오기 (file-ops와 동일 로직)
+ */
+function _getDesktopPath() {
+  try {
+    const { getDesktopPath } = require('./desktop-path');
+    return getDesktopPath();
+  } catch {
+    return path.join(os.homedir(), 'Desktop');
+  }
+}
+
+/**
+ * 소스 별칭을 실제 경로로 변환
+ * @param {string} alias - 소스 별칭 (예: "바탕화면")
+ * @returns {string|null} 실제 경로 또는 null
+ */
+function resolveSource(alias) {
+  if (!alias) return null;
+  const trimmed = alias.trim().toLowerCase();
+  for (const [key, resolver] of Object.entries(SOURCE_ALIASES)) {
+    if (trimmed === key || trimmed.includes(key)) {
+      return resolver();
+    }
+  }
+  return null;
+}
+
+/**
+ * 자동 분류 확장자 → 폴더명 매핑
+ * "바탕화면 정리해" 같은 범용 명령에서 사용
+ */
+const AUTO_CATEGORIES = {
+  '.png': '이미지',
+  '.jpg': '이미지',
+  '.jpeg': '이미지',
+  '.gif': '이미지',
+  '.bmp': '이미지',
+  '.webp': '이미지',
+  '.svg': '이미지',
+  '.pdf': '문서',
+  '.doc': '문서',
+  '.docx': '문서',
+  '.xlsx': '문서',
+  '.xls': '문서',
+  '.pptx': '문서',
+  '.ppt': '문서',
+  '.txt': '문서',
+  '.hwp': '문서',
+  '.md': '문서',
+  '.zip': '압축파일',
+  '.rar': '압축파일',
+  '.7z': '압축파일',
+  '.tar': '압축파일',
+  '.gz': '압축파일',
+  '.mp3': '음악',
+  '.wav': '음악',
+  '.flac': '음악',
+  '.aac': '음악',
+  '.mp4': '동영상',
+  '.avi': '동영상',
+  '.mkv': '동영상',
+  '.mov': '동영상',
+  '.wmv': '동영상',
+};
+
+/**
+ * 메시지에서 행동 명령을 감지
+ * @param {string} text - 사용자 메시지
+ * @returns {{ type: 'action', action: string }|null}
+ */
+function parseActionCommand(text) {
+  if (!text) return null;
+  const trimmed = text.trim().toLowerCase();
+
+  for (const [keyword, action] of Object.entries(ACTION_KEYWORDS)) {
+    if (trimmed === keyword || trimmed.includes(keyword)) {
+      return { type: 'action', action };
+    }
+  }
+  return null;
+}
+
+/**
+ * 메시지에서 파일 조작 명령을 감지
+ * @param {string} text - 사용자 메시지
+ * @returns {{ type: 'smart_file_op', source: string, filter: string, target: string, autoCategory: boolean }|null}
+ */
+function parseFileCommand(text) {
+  if (!text) return null;
+  const trimmed = text.trim();
+
+  // 패턴 1: "바탕화면의 .md 파일을 tata 폴더에 넣어줘"
+  const pattern1 = /(?:(.+?)(?:의|에서|에 있는)\s+)?([.\w*]+)\s*파일(?:을|들을)?\s+(.+?)(?:\s*폴더)?(?:에|으로)\s*(?:넣어|옮겨|이동|정리|보내)/;
+  let match = trimmed.match(pattern1);
+  if (match) {
+    const sourceName = match[1] || '바탕화면';
+    const filter = match[2];
+    const target = match[3].trim();
+    const source = resolveSource(sourceName) || _getDesktopPath();
+
+    return {
+      type: 'smart_file_op',
+      source,
+      filter: filter.startsWith('.') ? filter : `.${filter}`,
+      target,
+      autoCategory: false,
+    };
+  }
+
+  // 패턴 2: "스크린샷 폴더에 .png 정리해"
+  const pattern2 = /(.+?)(?:\s*폴더)?(?:에|으로)\s+([.\w*]+)\s*(?:파일\s*)?(?:정리|넣어|옮겨|이동)/;
+  match = trimmed.match(pattern2);
+  if (match) {
+    const target = match[1].trim();
+    const filter = match[2];
+
+    return {
+      type: 'smart_file_op',
+      source: _getDesktopPath(),
+      filter: filter.startsWith('.') ? filter : `.${filter}`,
+      target,
+      autoCategory: false,
+    };
+  }
+
+  // 패턴 3: "바탕화면 정리해" (자동 분류)
+  const pattern3 = /(.+?)\s*(?:정리|청소|깔끔하게)\s*(?:해|해줘|하자|좀)?$/;
+  match = trimmed.match(pattern3);
+  if (match) {
+    const sourceName = match[1].trim();
+    const source = resolveSource(sourceName);
+    if (source) {
+      return {
+        type: 'smart_file_op',
+        source,
+        filter: '*',
+        target: 'auto',
+        autoCategory: true,
+      };
+    }
+  }
+
+  // 패턴 4 (영어): "move .txt files to docs"
+  const pattern4 = /move\s+([.\w*]+)\s+files?\s+(?:to|into)\s+(\S+)/i;
+  match = trimmed.match(pattern4);
+  if (match) {
+    const filter = match[1];
+    const target = match[2];
+
+    return {
+      type: 'smart_file_op',
+      source: _getDesktopPath(),
+      filter: filter.startsWith('.') ? filter : `.${filter}`,
+      target,
+      autoCategory: false,
+    };
+  }
+
+  // 패턴 5 (영어): "clean up desktop" / "organize desktop"
+  const pattern5 = /(?:clean\s*(?:up)?|organize)\s+(\S+)/i;
+  match = trimmed.match(pattern5);
+  if (match) {
+    const sourceName = match[1].trim();
+    const source = resolveSource(sourceName);
+    if (source) {
+      return {
+        type: 'smart_file_op',
+        source,
+        filter: '*',
+        target: 'auto',
+        autoCategory: true,
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 캐릭터 변경 명령 감지
+ * @param {string} text - 사용자 메시지
+ * @returns {{ type: 'character_change', concept: string }|null}
+ */
+function parseCharacterCommand(text) {
+  if (!text) return null;
+  const trimmed = text.trim();
+
+  // 한국어 캐릭터 변경 패턴
+  const krPatterns = [
+    /(?:캐릭터|펫|모습|외형|외모)(?:를|을)?\s*(.+?)(?:로|으로)\s*(?:바꿔|변경|변신|만들어|바꿀래|바꾸고|바꿔줘|변경해|만들어줘)/,
+    /(.+?)(?:로|으로)\s*(?:캐릭터|펫|모습|외형)\s*(?:바꿔|변경|변신|변경해|바꿔줘)/,
+    /(.+?)\s*(?:캐릭터|펫)\s*(?:만들어|만들어줘|생성|생성해)/,
+    /(.+?)(?:로|으로)\s*변신(?:해|해줘|시켜|시켜줘)?/,
+  ];
+  for (const pattern of krPatterns) {
+    const match = trimmed.match(pattern);
+    if (match) {
+      return { type: 'character_change', concept: match[1].trim() };
+    }
+  }
+
+  // 영어 캐릭터 변경 패턴
+  const enPatterns = [
+    /(?:change|switch|transform)\s+(?:character|pet|look)\s+(?:to|into)\s+(.+)/i,
+    /(?:make|create|generate)\s+(?:a\s+)?(.+?)\s+(?:character|pet)/i,
+    /(?:become|turn into)\s+(?:a\s+)?(.+)/i,
+  ];
+  for (const pattern of enPatterns) {
+    const match = trimmed.match(pattern);
+    if (match) {
+      return { type: 'character_change', concept: match[1].trim() };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 메시지 종합 파싱: 캐릭터 변경 > 파일 조작 > 행동 명령 > 일반 대화 순으로 판별
+ * @param {string} text - 사용자 메시지
+ * @returns {{ type: string, ... }}
+ */
+function parseMessage(text) {
+  // 0순위: 캐릭터 변경 명령
+  const charCmd = parseCharacterCommand(text);
+  if (charCmd) return charCmd;
+
+  // 1순위: 파일 조작 명령
+  const fileCmd = parseFileCommand(text);
+  if (fileCmd) return fileCmd;
+
+  // 2순위: 행동 명령
+  const actionCmd = parseActionCommand(text);
+  if (actionCmd) return actionCmd;
+
+  // 3순위: 일반 대화 (speak)
+  return { type: 'speak', text };
+}
+
+module.exports = {
+  parseMessage,
+  parseFileCommand,
+  parseActionCommand,
+  parseCharacterCommand,
+  resolveSource,
+  AUTO_CATEGORIES,
+};

package/main/index.js

@@ -3,10 +3,12 @@ const path = require('path');
 const { setupTray } = require('./tray');
 const { registerIpcHandlers } = require('./ipc-handlers');
 const { AIBridge } = require('./ai-bridge');
+const { TelegramBot } = require('./telegram');
 
 let mainWindow = null;
 let launcherWindow = null;
 let aiBridge = null;
+let telegramBot = null;
 
 function createMainWindow() {
   const { width, height } = screen.getPrimaryDisplay().workAreaSize;
@@ -80,6 +82,12 @@ function startAIBridge(win) {
     'accessorize', 'ai_decision',
     // 공간 이동 명령 (OpenClaw이 집처럼 돌아다니기)
     'jump_to', 'rappel', 'release_thread', 'move_to_center', 'walk_on_window',
+    // 커스텀 이동 패턴
+    'register_movement', 'custom_move', 'stop_custom_move', 'list_movements',
+    // 스마트 파일 조작 (텔레그램/AI에서 트리거한 파일 이동 애니메이션)
+    'smart_file_op',
+    // 캐릭터 커스터마이징 (텔레그램에서 AI 생성)
+    'set_character', 'reset_character',
   ];
 
   commandTypes.forEach((type) => {
@@ -149,6 +157,9 @@ app.whenReady().then(() => {
   const bridge = startAIBridge(win);
   setupTray(win, bridge);
 
+  // 텔레그램 봇 초기화 (토큰 없으면 조용히 무시)
+  telegramBot = new TelegramBot(bridge);
+
   // 최초 설치 시 자동 시작 등록
   const { enableAutoStart, isAutoStartEnabled } = require('./autostart');
   if (!isAutoStartEnabled()) {
@@ -165,6 +176,7 @@ app.on('window-all-closed', () => {
 });
 
 app.on('before-quit', () => {
+  if (telegramBot) telegramBot.stop();
   if (aiBridge) aiBridge.stop();
 });
 

package/main/ipc-handlers.js

@@ -1,5 +1,7 @@
 const { ipcMain, screen, desktopCapturer } = require('electron');
 const { getDesktopFiles, moveFile, undoFileMove, undoAllMoves, getFileManifest } = require('./file-ops');
+const { executeSmartFileOp, undoSmartMove, undoAllSmartMoves, listFilteredFiles } = require('./smart-file-ops');
+const { parseMessage } = require('./file-command-parser');
 const Store = require('./store');
 
 const store = new Store('clawmate-config', {
@@ -119,6 +121,14 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
         case 'user_idle':
           bridge.reportIdleTime(data.idleSeconds);
           break;
+        case 'browsing':
+          // 브라우징 컨텍스트 (제목 + 커서 위치 + 화면 캡처) → AI 코멘트 생성
+          bridge.send('user_event', { event: 'browsing', ...data });
+          break;
+        default:
+          // 알 수 없는 이벤트도 AI에 전달 (확장성)
+          bridge.send('user_event', { event, ...data });
+          break;
       }
     }
   });
@@ -129,11 +139,103 @@ function registerIpcHandlers(getMainWindow, getAIBridge) {
     return bridge ? bridge.isConnected() : false;
   });
 
+  // 메트릭 보고 (렌더러 → main → OpenClaw)
+  ipcMain.on('report-metrics', (_, summary) => {
+    const bridge = getAIBridge();
+    if (bridge && bridge.isConnected()) {
+      bridge.reportMetrics(summary);
+    }
+  });
+
   // 열린 윈도우 위치/크기 조회
   ipcMain.handle('get-window-positions', async () => {
     const { getWindowPositions } = require('./platform');
     return await getWindowPositions();
   });
+
+  // 활성 윈도우 제목 조회 (브라우저 감시용)
+  ipcMain.handle('get-active-window-title', async () => {
+    const { getActiveWindowTitle } = require('./platform');
+    return await getActiveWindowTitle();
+  });
+
+  // 커서 위치 조회 (화면 좌표)
+  ipcMain.handle('get-cursor-position', () => {
+    const point = screen.getCursorScreenPoint();
+    return { x: point.x, y: point.y };
+  });
+
+  // === 스마트 파일 조작 IPC ===
+
+  // 파일 명령 파싱 (렌더러에서도 사용 가능)
+  ipcMain.handle('parse-file-command', (_, text) => {
+    return parseMessage(text);
+  });
+
+  // 필터된 파일 목록 조회
+  ipcMain.handle('list-filtered-files', async (_, sourceDir, filter) => {
+    return listFilteredFiles(sourceDir, filter);
+  });
+
+  // 스마트 파일 조작 실행
+  // 렌더러에서 직접 실행할 때 사용 (텔레그램 경유가 아닌 경우)
+  ipcMain.handle('smart-file-op', async (_, command) => {
+    const win = getMainWindow();
+    const callbacks = {
+      onStart: (totalFiles) => {
+        if (win && !win.isDestroyed()) {
+          win.webContents.send('ai-command', {
+            type: 'smart_file_op',
+            payload: { phase: 'start', totalFiles },
+          });
+        }
+      },
+      onPickUp: (fileName, index) => {
+        if (win && !win.isDestroyed()) {
+          win.webContents.send('ai-command', {
+            type: 'smart_file_op',
+            payload: { phase: 'pick_up', fileName, index },
+          });
+        }
+      },
+      onDrop: (fileName, targetName, index) => {
+        if (win && !win.isDestroyed()) {
+          win.webContents.send('ai-command', {
+            type: 'smart_file_op',
+            payload: { phase: 'drop', fileName, targetName, index },
+          });
+        }
+      },
+      onComplete: (result) => {
+        if (win && !win.isDestroyed()) {
+          win.webContents.send('ai-command', {
+            type: 'smart_file_op',
+            payload: { phase: 'complete', ...result },
+          });
+        }
+      },
+      onError: (error) => {
+        if (win && !win.isDestroyed()) {
+          win.webContents.send('ai-command', {
+            type: 'smart_file_op',
+            payload: { phase: 'error', error },
+          });
+        }
+      },
+    };
+
+    return await executeSmartFileOp(command, callbacks);
+  });
+
+  // 스마트 이동 되돌리기 (단일)
+  ipcMain.handle('undo-smart-move', async (_, moveId) => {
+    return undoSmartMove(moveId);
+  });
+
+  // 스마트 이동 전체 되돌리기
+  ipcMain.handle('undo-all-smart-moves', async () => {
+    return undoAllSmartMoves();
+  });
 }
 
 module.exports = { registerIpcHandlers };