OpenClaw × Antigravity でAIパートナーエージェントを開発する — ソースコード解析からカスタム機能実装まで

# Antigravity を起動
antigravity start
 
# または、Antigravity のエージェント機能で実行
antigravity agents run --task "Clone the OpenClaw repository and analyze its structure"

// Antigravity Agent のプロンプト例
 
const analyzeTask = {
  task: "OpenClaw のメモリ機能について詳しく解説してください",
 
  context: {
    repo: 'openclaw',
    files: [
      'src/memory/memory-manager.ts',
      'src/memory/sqlite-storage.ts',
      'src/memory/mongodb-storage.ts'
    ]
  },
 
  output: 'explanation_with_code_snippets'
};
 
// Antigravity が返すもの：
/*
## OpenClaw メモリシステムの解析
 
### 目的
ユーザーとの会話履歴とプロフィール情報を永続化・検索
 
### 実装パターン
1. メモリマネージャー（インターフェース定義）
2. ストレージ層（SQLite, MongoDB等）
3. キャッシュ層（高速アクセス）
 
### コード例：
```typescript
class MemoryManager {
  async storeConversation(userId, message, response) {
    // SQLiteに保存
    await this.db.insert('conversations', {
      userId,
      message,
      response,
      timestamp: Date.now()
    });
  }
 
  async searchMemory(userId, query) {
    // 過去の会話を検索
    const results = await this.db.search('conversations', {
      userId,
      message: { $contains: query }
    });
    return results;
  }
}

// skills/weather-japan.ts
 
import { Skill, SkillContext } from '../base-skill';
import axios from 'axios';
 
export class WeatherJapanSkill implements Skill {
  name = 'weather-japan';
  description = '日本の天気情報を取得';
 
  private apiKey = process.env.OPENWEATHERMAP_API_KEY;
  private japanCities = {
    'tokyo': { lat: 35.6762, lon: 139.6503 },
    'osaka': { lat: 34.6937, lon: 135.5023 },
    'kyoto': { lat: 35.0116, lon: 135.7681 },
    // ... 他の主要都市
  };
 
  async execute(context: SkillContext): Promise<SkillResult> {
    const city = context.params.city.toLowerCase();
 
    if (!this.japanCities[city]) {
      return {
        actionType: 'message',
        content: `申し訳ないですが、「${city}」の天気データがありません。`,
      };
    }
 
    const coords = this.japanCities[city];
 
    try {
      const response = await axios.get('https://api.openweathermap.org/data/2.5/weather', {
        params: {
          lat: coords.lat,
          lon: coords.lon,
          appid: this.apiKey,
          units: 'metric',
          lang: 'ja',
        }
      });
 
      const weather = response.data;
 
      // AIパートナーへの説明を生成
      const description = `
        ${city}の天気：${weather.weather[0].description}
        気温：${weather.main.temp}℃
        体感温度：${weather.main.feels_like}℃
        湿度：${weather.main.humidity}%
        風速：${weather.wind.speed}m/s
      `;
 
      // AIが前向きなアドバイスを追加するためのコンテキスト
      const recommendation = this.getRecommendation(weather);
 
      return {
        actionType: 'message',
        content: `${city}の天気情報だね。\n${description}\n${recommendation}`,
        metadata: {
          weather,
          skillName: this.name,
        }
      };
    } catch (error) {
      return {
        actionType: 'error',
        content: '天気情報の取得に失敗しました。後でもう一度試してください。'
      };
    }
  }
 
  private getRecommendation(weather): string {
    const condition = weather.weather[0].main;
    const temp = weather.main.temp;
 
    if (condition === 'Rain') {
      return '雨だから、傘を持ってね。室内活動もいいかも。';
    }
    if (temp > 30) {
      return '暑いからね。こまめに水分補給を。';
    }
    if (temp < 5) {
      return '寒いから、暖かいコートを着てね。';
    }
 
    return 'いい天気だね。外出もいいですよ。';
  }
}

// skills/schedule-manager.ts
 
export class ScheduleManagerSkill implements Skill {
  name = 'schedule-manager';
  description = 'ユーザーのスケジュール追加・確認';
 
  async execute(context: SkillContext): Promise<SkillResult> {
    const { action, details } = context.params;
 
    switch (action) {
      case 'add':
        return await this.addEvent(details);
      case 'list':
        return await this.listEvents(details);
      case 'remove':
        return await this.removeEvent(details);
      default:
        return { actionType: 'error', content: 'Unknown action' };
    }
  }
 
  private async addEvent(details) {
    // SQLite に保存
    const event = {
      id: uuid(),
      title: details.title,
      datetime: new Date(details.when),
      description: details.description,
      createdAt: Date.now(),
    };
 
    await this.db.insert('events', event);
 
    return {
      actionType: 'message',
      content: `「${event.title}」を${event.datetime.toLocaleString('ja-JP')}に追加したよ。`,
    };
  }
 
  private async listEvents(details) {
    const events = await this.db.query('events', {
      userId: details.userId,
      datetime: { $gte: Date.now() }  // 今後のイベント
    });
 
    if (events.length === 0) {
      return { actionType: 'message', content: '予定がないみたいだね。' };
    }
 
    const eventList = events
      .sort((a, b) => a.datetime - b.datetime)
      .map(e => `• ${e.title} (${e.datetime.toLocaleString('ja-JP')})`)
      .join('\n');
 
    return {
      actionType: 'message',
      content: `今後の予定：\n${eventList}`,
    };
  }
}

# agents.yaml - Antigravity で生成可能
 
agents:
  - id: "sakura"
    name: "Sakura (感情サポート)"
    llm: "claude-3-5-sonnet"
    personality: "caring_supportive"
    platforms: ["discord", "line"]
    capabilities:
      - emotional_support
      - life_advice
      - memory_continuity
 
  - id: "analyst"
    name: "Data Analyst"
    llm: "claude-3-5-sonnet"
    personality: "logical_detailed"
    platforms: ["discord"]
    capabilities:
      - data_analysis
      - visualization
      - statistical_inference
 
  - id: "mentor"
    name: "Tech Mentor"
    llm: "claude-3-5-sonnet"
    personality: "teaching_focused"
    platforms: ["telegram"]
    capabilities:
      - code_review
      - architecture_design
      - learning_guidance
 
# エージェント間通信ルール
inter_agent_communication:
  enabled: true
  strategy: "collaborative"
  rules:
    - trigger: "user mentions technical problem AND needs emotional support"
      collaboration: ["mentor", "sakura"]
      coordinator: "sakura"  # 最終的な返信はsakuraから
 
    - trigger: "user asks for data insights"
      collaboration: ["analyst"]
 
    - trigger: "complex multi-aspect question"
      collaboration: ["sakura", "analyst", "mentor"]
      coordinator: "sakura"

// Antigravity Agent タスク
 
const multiAgentTask = {
  task: "OpenClaw のマルチエージェントシステムを実装してください",
 
  requirements: {
    agents: ["sakura", "analyst", "mentor"],
    communication: "message-based",
    coordination: "master-detail pattern",
  },
 
  outputFiles: {
    agentRegistry: 'src/agents/agent-registry.ts',
    orchestrator: 'src/orchestrator/multi-agent-orchestrator.ts',
    messageRouter: 'src/routing/message-router.ts',
    tests: 'tests/multi-agent.test.ts',
  }
};
 
// Antigravity 出力例：

// src/orchestrator/multi-agent-orchestrator.ts
 
export class MultiAgentOrchestrator {
  private agents: Map<string, Agent> = new Map();
  private router: MessageRouter;
 
  async routeAndExecute(message: Message): Promise<Response> {
    // 1. メッセージから必要なエージェント判定
    const requiredAgents = await this.router.determineAgents(message);
 
    // 2. 単一エージェント処理
    if (requiredAgents.length === 1) {
      const agent = this.agents.get(requiredAgents[0]);
      return await agent.handleMessage(message);
    }
 
    // 3. マルチエージェント協力処理
    return await this.executeCollaborativeTask(message, requiredAgents);
  }
 
  private async executeCollaborativeTask(
    message: Message,
    agentIds: string[]
  ): Promise<Response> {
    const responses = new Map();
 
    // 並列実行（可能な限り）
    const promises = agentIds.map(async (agentId) => {
      const agent = this.agents.get(agentId);
      const response = await agent.handleMessage(message);
      responses.set(agentId, response);
    });
 
    await Promise.all(promises);
 
    // コーディネーター（通常は primary agent）が結果を統合
    const coordinatorId = 'sakura';  // 設定可能
    const coordinator = this.agents.get(coordinatorId);
 
    return await coordinator.synthesizeResponses({
      original_message: message,
      agent_responses: Object.fromEntries(responses),
    });
  }
}

// Antigravity Agent タスク
 
const testTask = {
  task: "weather-japan スキルの包括的なテストを作成してください",
 
  fileToTest: "skills/weather-japan.ts",
 
  testCases: [
    "正常系：東京の天気取得",
    "正常系：大阪の天気取得",
    "異常系：存在しない都市",
    "異常系：API エラー時の処理",
    "エッジケース：温度が極端に高い/低い場合の推奨表示",
  ]
};
 
// Antigravity 出力：

// tests/skills/weather-japan.test.ts
 
import { WeatherJapanSkill } from '../../src/skills/weather-japan';
import axios from 'axios';
 
jest.mock('axios');
 
describe('WeatherJapanSkill', () => {
  let skill: WeatherJapanSkill;
 
  beforeEach(() => {
    skill = new WeatherJapanSkill();
  });
 
  describe('正常系', () => {
    it('東京の天気情報を取得できる', async () => {
      const mockWeather = {
        weather: [{ description: '晴れ' }],
        main: { temp: 25, feels_like: 24, humidity: 60 },
        wind: { speed: 3 }
      };
 
      (axios.get as jest.Mock).mockResolvedValue({ data: mockWeather });
 
      const result = await skill.execute({
        params: { city: 'tokyo' }
      });
 
      expect(result.actionType).toBe('message');
      expect(result.content).toContain('東京');
      expect(result.content).toContain('25℃');
    });
 
    it('大阪の天気情報を取得できる', async () => {
      // 同様のテスト
    });
  });
 
  describe('異常系', () => {
    it('存在しない都市で適切なエラーメッセージ', async () => {
      const result = await skill.execute({
        params: { city: 'unknown_city' }
      });
 
      expect(result.actionType).toBe('message');
      expect(result.content).toContain('データがありません');
    });
 
    it('API エラー時の処理', async () => {
      (axios.get as jest.Mock).mockRejectedValue(
        new Error('API Error')
      );
 
      const result = await skill.execute({
        params: { city: 'tokyo' }
      });
 
      expect(result.actionType).toBe('error');
    });
  });
 
  describe('エッジケース', () => {
    it('高温時は水分補給を勧める', async () => {
      const mockWeather = {
        weather: [{ description: '晴れ' }],
        main: { temp: 35, feels_like: 38, humidity: 30 },
        wind: { speed: 1 }
      };
 
      (axios.get as jest.Mock).mockResolvedValue({ data: mockWeather });
 
      const result = await skill.execute({ params: { city: 'tokyo' } });
 
      expect(result.content).toContain('水分補給');
    });
  });
});

// tests/integration/multi-agent.integration.test.ts
 
describe('MultiAgent Integration', () => {
  let orchestrator: MultiAgentOrchestrator;
 
  beforeEach(async () => {
    orchestrator = new MultiAgentOrchestrator();
    await orchestrator.initialize();
  });
 
  it('感情サポートと技術アドバイスを組み合わせられる', async () => {
    const message = {
      content: 'プログラミングで悩んでるんだけど、つらい...',
      userId: 'user123',
      platform: 'discord',
    };
 
    const response = await orchestrator.routeAndExecute(message);
 
    // Sakura が感情部分を、Mentor が技術部分を担当
    expect(response.content).toContain('つらい');  // 感情部分
    expect(response.content).toContain('コード');    // 技術部分
    expect(response.coordinator).toBe('sakura');     // 統合は sakura
  });
});