clawmate 1.2.0 → 1.4.0

package/renderer/js/ai-controller.js

@@ -1,10 +1,10 @@
 /**
  * AI 행동 컨트롤러
  *
- * OpenClaw이 연결되면 → AI가 모든 행동을 결정
- * OpenClaw이 끊기면  → 자율 모드 (기존 FSM) 로 폴백
+ * AI가 연결되면 → AI가 모든 행동을 결정
+ * AI가 끊기면  → 자율 모드 (기존 FSM) 로 폴백
  *
- * OpenClaw AI가 결정하는 것:
+ * AI가 결정하는 것:
  * - 언제 뭐라고 말할지
  * - 어디로 움직일지
  * - 어떤 감정을 표현할지
@@ -32,7 +32,7 @@ const AIController = (() => {
       window.clawmate.onAIConnected(() => {
         connected = true;
         autonomousMode = false;
-        Speech.show('OpenClaw 연결됨... 의식이 깨어난다.');
+        Speech.show('AI 연결됨... 의식이 깨어난다.');
         StateMachine.forceState('excited');
       });
     }
@@ -47,7 +47,7 @@ const AIController = (() => {
   }
 
   /**
-   * OpenClaw AI로부터 온 명령 실행
+   * AI로부터 온 명령 실행
    */
   function handleAICommand(command) {
     const { type, payload } = command;
@@ -140,12 +140,317 @@ const AIController = (() => {
         // payload: { windowId, x, y }
         PetEngine.jumpTo(payload.x, payload.y);
         break;
+
+      // === 커스텀 이동 패턴 ===
+
+      case 'register_movement':
+        // AI가 JSON으로 이동 패턴 정의를 보내면 등록
+        // payload: { name, definition }
+        // definition: { type, params } — 각 타입별 파라미터
+        _registerAIMovement(payload.name, payload.definition);
+        break;
+
+      case 'custom_move':
+        // 등록된 커스텀 이동 패턴 실행
+        // payload: { name, params? }
+        if (!PetEngine.executeCustomMovement(payload.name, payload.params || {})) {
+          // 실행 실패 시 AI에 알림
+          if (window.clawmate.reportToAI) {
+            window.clawmate.reportToAI('custom_move_failed', {
+              name: payload.name,
+              available: PetEngine.getRegisteredMovements(),
+            });
+          }
+        }
+        break;
+
+      case 'stop_custom_move':
+        // 현재 커스텀 이동 강제 중지
+        PetEngine.stopCustomMovement();
+        break;
+
+      case 'list_movements':
+        // 등록된 이동 패턴 목록 요청
+        if (window.clawmate.reportToAI) {
+          window.clawmate.reportToAI('movement_list', {
+            movements: PetEngine.getRegisteredMovements(),
+          });
+        }
+        break;
+
+      // === 캐릭터 커스터마이징 ===
+      case 'set_character':
+        // AI가 생성한 새 캐릭터 데이터 적용
+        Character.setCharacterData(payload);
+        if (payload.speech) {
+          Speech.show(payload.speech);
+        } else {
+          Speech.show('변신 완료!');
+        }
+        StateMachine.forceState('excited');
+        setTimeout(() => {
+          if (StateMachine.getState() === 'excited') StateMachine.forceState('idle');
+        }, 2000);
+        break;
+
+      case 'reset_character':
+        // 원래 캐릭터로 복원
+        Character.resetCharacter();
+        Speech.show('원래 모습으로 돌아왔어!');
+        StateMachine.forceState('excited');
+        break;
+
+      // === 인격체 전환 (Incarnation 모드) ===
+      case 'set_persona':
+        // 봇 인격체 데이터 적용
+        if (typeof ModeManager !== 'undefined') {
+          ModeManager.setPersona(payload);
+          const name = payload.name || 'Claw';
+          Speech.show(`${name}의 인격이 깨어났다.`);
+          StateMachine.forceState('excited');
+        }
+        break;
+
+      // === 스마트 파일 조작 애니메이션 ===
+      case 'smart_file_op':
+        handleSmartFileOp(payload);
+        break;
+    }
+  }
+
+  /**
+   * 스마트 파일 조작 애니메이션 처리
+   *
+   * 텔레그램이나 AI에서 트리거된 파일 이동 작업의
+   * 각 단계(phase)에 따라 펫 애니메이션을 순차 실행.
+   *
+   * phase:
+   *   - start: 작업 시작, 총 파일 수 표시
+   *   - pick_up: 파일 집어들기 (carrying 상태 + 말풍선)
+   *   - drop: 파일 내려놓기 (걷기 상태 + 말풍선)
+   *   - complete: 완료 (excited 상태 + 결과 말풍선)
+   *   - error: 오류 (scared 상태 + 에러 말풍선)
+   */
+  function handleSmartFileOp(payload) {
+    switch (payload.phase) {
+      case 'start':
+        StateMachine.forceState('excited');
+        Speech.show(`${payload.totalFiles}개 파일 정리 시작!`);
+        break;
+
+      case 'pick_up':
+        // 펫이 파일 위치로 이동 (화면 내 랜덤 위치)
+        _smartFileJumpToSource(payload.index);
+        // 집어들기 애니메이션
+        setTimeout(() => {
+          StateMachine.forceState('carrying');
+          Speech.show(`${payload.fileName} 집었다!`);
+        }, 400);
+        break;
+
+      case 'drop':
+        // 대상 폴더 위치로 이동
+        _smartFileJumpToTarget(payload.index);
+        // 내려놓기 애니메이션
+        setTimeout(() => {
+          StateMachine.forceState('walking');
+          Speech.show(`여기! (${payload.targetName})`);
+        }, 400);
+        break;
+
+      case 'complete':
+        StateMachine.forceState('excited');
+        if (payload.movedCount > 0) {
+          Speech.show(`${payload.movedCount}개 파일 옮겼어!`);
+        } else {
+          Speech.show('옮길 파일이 없었어!');
+        }
+        break;
+
+      case 'error':
+        StateMachine.forceState('scared');
+        Speech.show('앗, 뭔가 잘못됐어...');
+        break;
+    }
+  }
+
+  /**
+   * 파일 집어들기 위치로 점프
+   * 파일 인덱스에 따라 화면 좌측 영역의 다른 위치로 이동
+   */
+  function _smartFileJumpToSource(index) {
+    const screenW = window.innerWidth;
+    const screenH = window.innerHeight;
+    // 화면 왼쪽 1/3 영역에서 세로 위치를 파일 인덱스에 따라 분산
+    const targetX = screenW * 0.1 + (index % 3) * 50;
+    const targetY = screenH * 0.3 + ((index * 80) % (screenH * 0.5));
+    PetEngine.jumpTo(targetX, targetY);
+  }
+
+  /**
+   * 파일 내려놓기 위치로 점프
+   * 화면 오른쪽 영역으로 이동
+   */
+  function _smartFileJumpToTarget(index) {
+    const screenW = window.innerWidth;
+    const screenH = window.innerHeight;
+    // 화면 오른쪽 1/3 영역
+    const targetX = screenW * 0.7 + (index % 3) * 50;
+    const targetY = screenH * 0.4 + ((index * 60) % (screenH * 0.4));
+    PetEngine.jumpTo(targetX, targetY);
+  }
+
+  /**
+   * AI가 JSON으로 정의한 이동 패턴을 동적으로 등록
+   * 안전한 실행을 위해 Function 생성자 대신 사전정의된 행동 유형 조합 사용
+   *
+   * definition 형식:
+   * {
+   *   type: 'waypoints' | 'formula' | 'sequence',
+   *   waypoints?: [{x, y, pause?}],          // waypoints 타입
+   *   formula?: { xExpr, yExpr },             // formula 타입 (sin, cos 기반)
+   *   sequence?: ['zigzag', 'shake', ...],    // sequence 타입 (기존 패턴 순차 실행)
+   *   duration?: number,
+   *   speed?: number,
+   * }
+   */
+  function _registerAIMovement(name, definition) {
+    if (!name || !definition || !definition.type) {
+      console.warn('[AIController] 이동 패턴 등록 실패: name, definition.type 필수');
+      return;
+    }
+
+    let handler;
+
+    switch (definition.type) {
+      // 웨이포인트 타입: 지정된 좌표들을 순서대로 이동
+      case 'waypoints':
+        handler = {
+          init(params) {
+            return {
+              waypoints: definition.waypoints || [],
+              currentIdx: 0,
+              speed: definition.speed || 2,
+              pauseTime: 0,
+              pausing: false,
+            };
+          },
+          update(dt, state, ctx) {
+            if (state.currentIdx >= state.waypoints.length) return;
+
+            const wp = state.waypoints[state.currentIdx];
+
+            // 웨이포인트에서 멈춤 중
+            if (state.pausing) {
+              state.pauseTime -= dt;
+              if (state.pauseTime <= 0) {
+                state.pausing = false;
+                state.currentIdx++;
+              }
+              return;
+            }
+
+            const dx = wp.x - ctx.x;
+            const dy = wp.y - ctx.y;
+            const dist = Math.hypot(dx, dy);
+
+            if (dist < 5) {
+              // 웨이포인트 도달
+              if (wp.pause && wp.pause > 0) {
+                state.pausing = true;
+                state.pauseTime = wp.pause;
+              } else {
+                state.currentIdx++;
+              }
+              return;
+            }
+
+            const step = state.speed * (dt / 16);
+            const ratio = Math.min(1, step / dist);
+            ctx.setPos(ctx.x + dx * ratio, ctx.y + dy * ratio);
+            ctx.setFlip(dx < 0);
+          },
+          isComplete(state) {
+            return state.currentIdx >= (state.waypoints || []).length;
+          },
+          cleanup() {},
+        };
+        break;
+
+      // 수식 타입: sin/cos 기반 수학적 궤도
+      case 'formula':
+        handler = {
+          init(params) {
+            return {
+              duration: definition.duration || 3000,
+              elapsed: 0,
+              originX: params.x,
+              originY: params.y,
+              xAmp: definition.formula?.xAmp || 50,
+              yAmp: definition.formula?.yAmp || 30,
+              xFreq: definition.formula?.xFreq || 1,
+              yFreq: definition.formula?.yFreq || 1,
+              xPhase: definition.formula?.xPhase || 0,
+              yPhase: definition.formula?.yPhase || 0,
+            };
+          },
+          update(dt, state, ctx) {
+            state.elapsed += dt;
+            const t = (state.elapsed / state.duration) * Math.PI * 2;
+            const nx = state.originX + Math.sin(t * state.xFreq + state.xPhase) * state.xAmp;
+            const ny = state.originY + Math.sin(t * state.yFreq + state.yPhase) * state.yAmp;
+            ctx.setPos(nx, ny);
+            ctx.setFlip(Math.cos(t * state.xFreq + state.xPhase) < 0);
+          },
+          isComplete(state) {
+            return state.elapsed >= state.duration;
+          },
+          cleanup() {},
+        };
+        break;
+
+      // 시퀀스 타입: 기존 등록된 패턴들을 순차 실행
+      case 'sequence':
+        handler = {
+          init(params) {
+            return {
+              sequence: definition.sequence || [],
+              currentIdx: 0,
+              subStarted: false,
+            };
+          },
+          update(dt, state, ctx) {
+            if (state.currentIdx >= state.sequence.length) return;
+
+            if (!state.subStarted) {
+              const subName = state.sequence[state.currentIdx];
+              // 서브 패턴을 직접 실행하지 않고 상태만 추적
+              PetEngine.executeCustomMovement(subName, {
+                x: ctx.x, y: ctx.y,
+                screenW: ctx.screenW, screenH: ctx.screenH,
+              });
+              state.subStarted = true;
+            }
+          },
+          isComplete(state) {
+            return state.currentIdx >= (state.sequence || []).length;
+          },
+          cleanup() {},
+        };
+        break;
+
+      default:
+        console.warn(`[AIController] 알 수 없는 이동 패턴 타입: ${definition.type}`);
+        return;
     }
+
+    PetEngine.registerMovement(name, handler);
+    console.log(`[AIController] AI 이동 패턴 등록됨: ${name} (${definition.type})`);
   }
 
   /**
    * AI 종합 의사결정 실행
-   * OpenClaw이 상황을 분석하고 내린 복합적 결정
+   * AI가 상황을 분석하고 내린 복합적 결정
    *
    * 예시:
    * {
@@ -202,7 +507,7 @@ const AIController = (() => {
     StateMachine.forceState(state);
   }
 
-  // === 사용자 이벤트 → OpenClaw에 리포트 ===
+  // === 사용자 이벤트 → AI에 리포트 ===
 
   function reportClick(position) {
     if (window.clawmate.reportToAI) {

package/renderer/js/app.js

@@ -2,12 +2,12 @@
  * ClawMate 렌더러 초기화
  *
  * 아키텍처:
- *   OpenClaw AI (뇌) ←→ AI Bridge (WebSocket) ←→ AI Controller (렌더러)
+ *   AI (뇌) ←→ AI Bridge (WebSocket) ←→ AI Controller (렌더러)
  *                                                       ↓
  *                                          StateMachine / PetEngine / Speech
  *
- * OpenClaw 연결 시: AI가 모든 행동/말/감정 결정
- * OpenClaw 미연결 시: 자율 모드 (FSM 기반) 로 혼자 놀기
+ * AI 연결 시: AI가 모든 행동/말/감정 결정
+ * AI 미연결 시: 자율 모드 (FSM 기반) 로 혼자 놀기
  */
 (async function initClawMate() {
   const petContainer = document.getElementById('pet-container');
@@ -45,7 +45,10 @@
       Interactions.spawnStarEffect();
     }
 
-    // 상태 변화를 OpenClaw에 리포트
+    // 모션 히스토리 기록
+    Memory.recordMotion(newState);
+
+    // 상태 변화를 AI에 리포트
     if (window.clawmate.reportToAI) {
       window.clawmate.reportToAI('state_change', {
         from: prevState, to: newState,
@@ -62,7 +65,7 @@
   // 메모리 초기화 (진화 상태 포함)
   await Memory.init();
 
-  // AI 컨트롤러 초기화 (OpenClaw 연결 관리)
+  // AI 컨트롤러 초기화 (AI 연결 관리)
   AIController.init();
 
   // 상호작용 초기화
@@ -71,6 +74,16 @@
   // 시간 인식 초기화 (자율 모드에서만 주도적으로 동작)
   TimeAware.init();
 
+  // 메트릭 수집기 초기화 (선택적 — 없어도 앱 정상 동작)
+  if (typeof Metrics !== 'undefined') {
+    Metrics.init();
+  }
+
+  // 브라우저 감시 초기화 (참견쟁이 모드)
+  if (typeof BrowserWatcher !== 'undefined') {
+    BrowserWatcher.init();
+  }
+
   // 엔진 시작
   PetEngine.start();
 
@@ -82,7 +95,7 @@
   // AI 연결 상태 표시
   const connected = await window.clawmate.isAIConnected();
   if (connected) {
-    Speech.show('OpenClaw과 연결됨. 지시를 기다리는 중...');
+    Speech.show('AI와 연결됨. 지시를 기다리는 중...');
   } else {
     Speech.show('안녕! 나 혼자서도 잘 놀 수 있어!');
   }

package/renderer/js/browser-watcher.js

@@ -0,0 +1,172 @@
+/**
+ * 브라우저 활동 감시 + AI 코멘트 시스템
+ *
+ * 두 가지 모드:
+ *   AI 연결 시: 윈도우 제목 + 화면 캡처 + 커서 위치를 AI에 전송 → AI가 맥락 있는 코멘트 생성
+ *   AI 미연결 시: 프리셋 메시지로 폴백 (자율 모드)
+ *
+ * 동작:
+ *   1. 15초마다 활성 윈도우 제목 + 커서 위치 조회
+ *   2. 브라우저/앱 감지 시 AI에 컨텍스트 리포트 (제목 + 화면 캡처)
+ *   3. AI가 제목/캡처를 분석해서 상황 맞는 코멘트 생성
+ *   4. 자율 모드에서는 프리셋 메시지 폴백
+ */
+const BrowserWatcher = (() => {
+  const CHECK_INTERVAL = 15000;     // 활성 윈도우 체크 주기 (15초)
+  const AI_COOLDOWN = 45000;        // AI 코멘트 쿨다운 (45초)
+  const FALLBACK_COOLDOWN = 90000;  // 자율 모드 코멘트 쿨다운 (90초)
+  const COMMENT_CHANCE = 0.4;       // 코멘트 확률 (40%)
+  const SITE_CHANGE_BONUS = 0.3;    // 사이트 변경 시 추가 확률
+
+  let intervalId = null;
+  let lastCategory = null;
+  let lastCommentTime = 0;
+  let lastTitle = '';
+  let enabled = true;
+
+  function init() {
+    intervalId = setInterval(check, CHECK_INTERVAL);
+    // 첫 체크는 10초 후 (앱 시작 직후는 건너뜀)
+    setTimeout(check, 10000);
+  }
+
+  async function check() {
+    if (!enabled) return;
+    if (typeof Speech === 'undefined') return;
+
+    // sleeping 상태면 참견 안 함
+    if (typeof StateMachine !== 'undefined' && StateMachine.getState() === 'sleeping') return;
+
+    try {
+      const title = await window.clawmate.getActiveWindowTitle();
+      if (!title) return;
+
+      const titleLower = title.toLowerCase();
+      const titleChanged = title !== lastTitle;
+      lastTitle = title;
+
+      const now = Date.now();
+
+      // 카테고리 매칭 (AI/자율 모두 사용)
+      const msgs = window._messages;
+      const match = msgs?.browsing ? findCategory(titleLower, msgs.browsing) : null;
+      const category = match?.category || 'unknown';
+
+      // 쿨다운 체크
+      const isAI = typeof AIController !== 'undefined' && AIController.isConnected();
+      const cooldown = isAI ? AI_COOLDOWN : FALLBACK_COOLDOWN;
+      if (now - lastCommentTime < cooldown) return;
+
+      // 같은 카테고리 + 제목 미변경 시 스킵
+      if (category === lastCategory && !titleChanged) return;
+
+      // 확률 체크
+      let chance = COMMENT_CHANCE;
+      if (titleChanged) chance += SITE_CHANGE_BONUS;
+      if (Math.random() > chance) return;
+
+      // === AI vs 자율 모드 분기 ===
+      if (isAI) {
+        await reportBrowsingToAI(title, category, titleChanged);
+      } else {
+        showFallbackComment(match);
+      }
+
+      lastCategory = category;
+      lastCommentTime = now;
+    } catch {
+      // IPC 실패 무시
+    }
+  }
+
+  /**
+   * AI에 브라우징 컨텍스트 전송
+   * 제목 + 커서 위치 + 화면 캡처를 한번에 전송
+   * AI가 분석하고 코멘트 생성
+   */
+  async function reportBrowsingToAI(title, category, titleChanged) {
+    if (!window.clawmate.reportToAI) return;
+
+    // 커서 위치 조회
+    let cursorX = 0, cursorY = 0;
+    try {
+      if (window.clawmate.getCursorPosition) {
+        const pos = await window.clawmate.getCursorPosition();
+        cursorX = pos.x;
+        cursorY = pos.y;
+      }
+    } catch {}
+
+    // 화면 캡처 (AI가 페이지 내용을 시각적으로 분석하기 위해)
+    let screenData = null;
+    try {
+      const capture = await window.clawmate.screen.capture();
+      if (capture?.success) {
+        screenData = {
+          image: capture.image,
+          width: capture.width,
+          height: capture.height,
+        };
+      }
+    } catch {}
+
+    // 통합 브라우징 리포트 전송
+    window.clawmate.reportToAI('browsing', {
+      title,
+      category,
+      titleChanged,
+      cursorX,
+      cursorY,
+      screen: screenData,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * 자율 모드 폴백: 프리셋 메시지 표시
+   */
+  function showFallbackComment(match) {
+    if (!match?.data?.comments) return;
+
+    const comments = match.data.comments;
+    const comment = comments[Math.floor(Math.random() * comments.length)];
+    Speech.show(comment);
+
+    // 50% 확률로 흥분 애니메이션
+    if (typeof StateMachine !== 'undefined') {
+      const state = StateMachine.getState();
+      if ((state === 'idle' || state === 'walking') && Math.random() < 0.5) {
+        StateMachine.forceState('excited');
+        setTimeout(() => {
+          if (StateMachine.getState() === 'excited') StateMachine.forceState('idle');
+        }, 1500);
+      }
+    }
+  }
+
+  /**
+   * 카테고리 매칭 (키워드 기반)
+   * general은 다른 카테고리 매칭 안 될 때만 사용
+   */
+  function findCategory(titleLower, browsingMsgs) {
+    let generalMatch = null;
+    for (const [category, data] of Object.entries(browsingMsgs)) {
+      if (!data.keywords) continue;
+      for (const keyword of data.keywords) {
+        if (titleLower.includes(keyword.toLowerCase())) {
+          if (category === 'general') {
+            generalMatch = { category, data };
+          } else {
+            return { category, data };
+          }
+        }
+      }
+    }
+    return generalMatch;
+  }
+
+  function setEnabled(val) { enabled = val; }
+  function stop() { if (intervalId) clearInterval(intervalId); }
+
+  return { init, stop, setEnabled, check };
+})();