Antigravity × Durable Execution: 障害に強い長時間AIタスクの設計パターン

// trigger/ai-processing.ts
// Trigger.dev v3 による Durable Execution ワークフロー
 
import { task, wait, retry } from "@trigger.dev/sdk/v3";
 
export const processLargeCodebase = task({
  id: "process-large-codebase",
  // 最大実行時間: 2時間
  maxDuration: 7200,
  retry: {
    maxAttempts: 5,
    factor: 2,
    minTimeoutInMs: 1000,
    maxTimeoutInMs: 60000,
  },
  run: async (payload: { repoUrl: string; branch: string }) => {
    // Step 1: リポジトリのクローン（自動チェックポイント）
    const cloneResult = await cloneRepo(payload.repoUrl, payload.branch);
    // Trigger.dev が自動的に状態を永続化
 
    // Step 2: ファイル解析（大量ファイルのバッチ処理）
    const files = await listSourceFiles(cloneResult.path);
    const analysisResults = [];
 
    for (const file of files) {
      // 各ファイルの解析結果が自動的にチェックポイントされる
      const analysis = await retry.onThrow(
        async () => {
          return await analyzeFileWithAI(file);
        },
        { maxAttempts: 3, randomize: true }
      );
      analysisResults.push(analysis);
    }
 
    // Step 3: レポート生成
    const report = generateReport(analysisResults);
 
    // Step 4: 通知
    await sendNotification({
      type: "analysis-complete",
      summary: report.summary,
      issuesFound: report.issues.length,
    });
 
    return report;
  },
});
 
async function cloneRepo(url: string, branch: string) {
  // リポジトリクローン処理
  return { path: `/tmp/repo-${Date.now()}` };
}
 
async function listSourceFiles(repoPath: string) {
  // ソースファイル一覧取得
  return ["src/index.ts", "src/utils.ts", "src/api/routes.ts"];
}
 
async function analyzeFileWithAI(filePath: string) {
  // AI による静的解析（外部API呼び出し）
  return { file: filePath, issues: [], score: 85 };
}
 
function generateReport(results: any[]) {
  return {
    summary: `Analyzed ${results.length} files`,
    issues: results.flatMap((r) => r.issues),
    averageScore: results.reduce((s, r) => s + r.score, 0) / results.length,
  };
}
 
async function sendNotification(data: any) {
  console.log("Notification sent:", data);
}

// idempotency-patterns.ts
// べき等性を確保するための実装パターン集
 
import { randomUUID } from "crypto";
 
// パターン 1: べき等キーによる重複排除
class IdempotentExecutor {
  private processedKeys = new Set<string>();
 
  async execute(
    idempotencyKey: string,
    operation: () => Promise<void>
  ): Promise<void> {
    // 既に処理済みならスキップ
    if (this.processedKeys.has(idempotencyKey)) {
      console.log(`Already processed: ${idempotencyKey}`);
      return;
    }
 
    await operation();
    this.processedKeys.add(idempotencyKey);
  }
}
 
// パターン 2: Upsert による DB 書き込みのべき等化
async function upsertRecord(db: any, record: { id: string; data: any }) {
  // INSERT ... ON CONFLICT DO UPDATE で同じレコードを何度書いても結果が同じ
  await db.query(
    `INSERT INTO records (id, data, updated_at)
     VALUES ($1, $2, NOW())
     ON CONFLICT (id) DO UPDATE SET data = $2, updated_at = NOW()`,
    [record.id, JSON.stringify(record.data)]
  );
  // 期待する出力: 1行が挿入または更新される（重複なし）
}
 
// パターン 3: トランザクションIDによる決済のべき等化
async function processPayment(orderId: string, amount: number) {
  const transactionId = `txn_${orderId}_${amount}`;
  // Stripe の idempotencyKey を使用
  const payment = await stripe.paymentIntents.create(
    {
      amount: amount,
      currency: "jpy",
      metadata: { orderId },
    },
    {
      idempotencyKey: transactionId,
    }
  );
  return payment;
  // 同じ transactionId で何度呼んでも1回分しか課金されない
}
 
const stripe = { paymentIntents: { create: async (...args: any[]) => ({}) } };

// agent-durable-workflow.ts
// Antigravity エージェントの処理を Durable に管理する
 
interface AgentTask {
  id: string;
  type: "code-review" | "refactor" | "test-gen";
  targetFiles: string[];
  status: "pending" | "running" | "completed" | "failed";
  result?: unknown;
}
 
class DurableAgentOrchestrator {
  private tasks: Map<string, AgentTask> = new Map();
  private checkpointFile: string;
 
  constructor(sessionId: string) {
    this.checkpointFile = `.agent-state/${sessionId}.json`;
    this.restore();
  }
 
  private restore(): void {
    try {
      const fs = require("fs");
      if (fs.existsSync(this.checkpointFile)) {
        const saved = JSON.parse(
          fs.readFileSync(this.checkpointFile, "utf-8")
        );
        this.tasks = new Map(Object.entries(saved.tasks));
        console.log(
          `Restored ${this.tasks.size} tasks from checkpoint`
        );
      }
    } catch {
      // 新規セッション
    }
  }
 
  private checkpoint(): void {
    const fs = require("fs");
    const path = require("path");
    fs.mkdirSync(path.dirname(this.checkpointFile), { recursive: true });
    const serialized = {
      tasks: Object.fromEntries(this.tasks),
      savedAt: new Date().toISOString(),
    };
    fs.writeFileSync(
      this.checkpointFile,
      JSON.stringify(serialized, null, 2)
    );
  }
 
  async submitTask(task: Omit<AgentTask, "status">): Promise<string> {
    const existing = this.tasks.get(task.id);
    if (existing?.status === "completed") {
      console.log(`Task ${task.id} already completed, returning cached result`);
      return task.id;
    }
 
    this.tasks.set(task.id, { ...task, status: "pending" });
    this.checkpoint();
    return task.id;
  }
 
  async runAll(): Promise<Map<string, AgentTask>> {
    const pending = [...this.tasks.values()].filter(
      (t) => t.status !== "completed"
    );
 
    for (const task of pending) {
      task.status = "running";
      this.checkpoint();
 
      try {
        // Antigravity エージェントへタスクを委譲
        task.result = await this.delegateToAgent(task);
        task.status = "completed";
      } catch (error) {
        task.status = "failed";
        console.error(`Task ${task.id} failed:`, error);
      }
      this.checkpoint();
    }
 
    return this.tasks;
  }
 
  private async delegateToAgent(task: AgentTask): Promise<unknown> {
    // 実際にはAntigravityのエージェントAPIを呼び出す
    console.log(`Delegating ${task.type} to agent for ${task.targetFiles}`);
    return { reviewed: true, suggestions: [] };
  }
}
 
// 使用例
async function main() {
  const orchestrator = new DurableAgentOrchestrator("session-20260330");
 
  await orchestrator.submitTask({
    id: "review-auth",
    type: "code-review",
    targetFiles: ["src/auth/login.ts", "src/auth/session.ts"],
  });
 
  await orchestrator.submitTask({
    id: "refactor-api",
    type: "refactor",
    targetFiles: ["src/api/routes.ts"],
  });
 
  await orchestrator.submitTask({
    id: "gen-tests",
    type: "test-gen",
    targetFiles: ["src/utils/parser.ts"],
  });
 
  const results = await orchestrator.runAll();
  console.log("All tasks complete:", results.size);
  // 期待する出力: All tasks complete: 3
}
 
main().catch(console.error);