// Hard to test, impossible to visualize, breaks under complex conditions
async function run() {
  while (true) {
    const result = await claude.think(context);
    if (result.needsApproval) {
      if (await getApproval()) {
        // ...nested logic
      }
    } else if (result.isDone) {
      break;
    }
    // What if claude throws? What if approval times out? What state are we in?
  }
}

idle → thinking → (needs_approval → approved/rejected) | (executing → done | failed)

npm install xstate @xstate/react @anthropic-ai/sdk
npm install -D @xstate/inspect  # optional: visual debugger

// lib/code-review-machine.ts
import { createMachine, assign, fromPromise } from "xstate";
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// ── Types ─────────────────────────────────────────────────────────────────────

interface ReviewContext {
  prDiff: string;
  prUrl: string;
  analysis: {
    summary: string;
    riskLevel: "low" | "medium" | "high";
    issues: Array<{ file: string; line: number; message: string; severity: string }>;
    approved: boolean;
  } | null;
  approvalRequestedAt: Date | null;
  postedReviewId: string | null;
  error: string | null;
  retryCount: number;
}

type ReviewEvent =
  | { type: "START"; prDiff: string; prUrl: string }
  | { type: "APPROVAL_GRANTED" }
  | { type: "APPROVAL_REJECTED" }
  | { type: "RETRY" };

// ── Actors (async operations) ─────────────────────────────────────────────────

const analyzeWithClaude = fromPromise(async ({ input }: { input: { diff: string } }) => {
  const msg = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: `Analyze this PR diff for code quality, security issues, and bugs.
Output JSON matching this schema:
{
  "summary": "one sentence summary",
  "riskLevel": "low" | "medium" | "high",
  "approved": boolean,
  "issues": [{ "file": string, "line": number, "message": string, "severity": "info"|"warning"|"error" }]
}

Diff:
\`\`\`
${input.diff}
\`\`\``,
      },
    ],
  });

  const text = (msg.content[0] as { type: "text"; text: string }).text;
  return JSON.parse(text.match(/\{[\s\S]*\}/)?.[0] ?? "{}");
});

const postReview = fromPromise(async ({
  input,
}: {
  input: { prUrl: string; analysis: ReviewContext["analysis"] };
}) => {
  // Post to GitHub via Octokit — implementation details omitted
  const reviewId = `review-${Date.now()}`;
  console.log(`Posted review to ${input.prUrl}:`, input.analysis?.summary);
  return reviewId;
});

// ── Machine Definition ─────────────────────────────────────────────────────────

export const codeReviewMachine = createMachine(
  {
    id: "codeReview",
    initial: "idle",
    types: {} as {
      context: ReviewContext;
      events: ReviewEvent;
    },
    context: {
      prDiff: "",
      prUrl: "",
      analysis: null,
      approvalRequestedAt: null,
      postedReviewId: null,
      error: null,
      retryCount: 0,
    },
    states: {
      idle: {
        on: {
          START: {
            target: "analyzing",
            actions: assign({
              prDiff: ({ event }) => event.prDiff,
              prUrl: ({ event }) => event.prUrl,
              error: null,
              retryCount: 0,
            }),
          },
        },
      },

      analyzing: {
        invoke: {
          src: analyzeWithClaude,
          input: ({ context }) => ({ diff: context.prDiff }),
          onDone: [
            // High-risk changes require human approval
            {
              guard: ({ event }) => event.output?.riskLevel === "high",
              target: "awaitingApproval",
              actions: assign({ analysis: ({ event }) => event.output }),
            },
            // Low/medium risk: post automatically
            {
              target: "posting",
              actions: assign({ analysis: ({ event }) => event.output }),
            },
          ],
          onError: {
            target: "failed",
            actions: assign({ error: ({ event }) => String(event.error) }),
          },
        },
      },

      awaitingApproval: {
        entry: assign({ approvalRequestedAt: () => new Date() }),
        on: {
          APPROVAL_GRANTED: "posting",
          APPROVAL_REJECTED: "rejected",
        },
        after: {
          // Auto-reject if no human response within 24 hours
          86_400_000: {
            target: "rejected",
            actions: assign({ error: () => "Approval timeout — auto-rejected after 24h" }),
          },
        },
      },

      posting: {
        invoke: {
          src: postReview,
          input: ({ context }) => ({
            prUrl: context.prUrl,
            analysis: context.analysis,
          }),
          onDone: {
            target: "done",
            actions: assign({ postedReviewId: ({ event }) => event.output }),
          },
          onError: [
            // Retry up to 3 times before giving up
            {
              guard: ({ context }) => context.retryCount < 3,
              target: "posting",
              actions: assign({ retryCount: ({ context }) => context.retryCount + 1 }),
            },
            {
              target: "failed",
              actions: assign({ error: ({ event }) => String(event.error) }),
            },
          ],
        },
      },

      done: { type: "final" },
      rejected: { type: "final" },
      failed: {
        on: {
          RETRY: {
            target: "analyzing",
            actions: assign({ error: null }),
          },
        },
      },
    },
  },
  {
    actors: { analyzeWithClaude, postReview },
  }
);

// lib/run-review.ts
import { createActor } from "xstate";
import { codeReviewMachine } from "./code-review-machine";

export function createReviewActor(prDiff: string, prUrl: string) {
  const actor = createActor(codeReviewMachine);

  actor.subscribe((snapshot) => {
    const { value, context } = snapshot;
    console.log(`[CodeReview] State: ${String(value)}`);

    if (value === "awaitingApproval") {
      console.log(
        `⚠️  High-risk PR detected. Risk: ${context.analysis?.riskLevel}`,
        "\n   Issues:",
        context.analysis?.issues?.filter((i) => i.severity === "error")
      );
      // Send Slack/email notification to human reviewer here
    }

    if (value === "done") {
      console.log(`✅ Review posted: ${context.postedReviewId}`);
    }

    if (value === "failed") {
      console.error(`❌ Review failed: ${context.error}`);
    }
  });

  actor.start();
  actor.send({ type: "START", prDiff, prUrl });

  return actor;
}

const contentPipelineMachine = createMachine({
  id: "contentPipeline",
  type: "parallel",   // All child states run concurrently
  states: {
    // Generates draft article
    writing: {
      initial: "drafting",
      states: {
        drafting: {
          invoke: {
            src: "generateDraft",
            onDone: "done",
          },
        },
        done: { type: "final" },
      },
    },
    // Simultaneously generates SEO metadata
    seo: {
      initial: "generating",
      states: {
        generating: {
          invoke: {
            src: "generateSEOMeta",
            onDone: "done",
          },
        },
        done: { type: "final" },
      },
    },
    // And generates social media snippets
    social: {
      initial: "generating",
      states: {
        generating: {
          invoke: {
            src: "generateSocialSnippets",
            onDone: "done",
          },
        },
        done: { type: "final" },
      },
    },
  },
  // Automatically transitions when ALL parallel states reach "final"
  onDone: "#contentPipeline.publishing",
});

// lib/persist-machine.ts
import { redis } from "./redis";
import { createActor, type AnyMachineSnapshot } from "xstate";
import { codeReviewMachine } from "./code-review-machine";

const STATE_TTL = 60 * 60 * 48; // 48 hours

export async function saveSnapshot(id: string, snapshot: AnyMachineSnapshot) {
  await redis.setex(`machine:${id}`, STATE_TTL, JSON.stringify(snapshot));
}

export async function loadSnapshot(id: string): Promise<AnyMachineSnapshot | null> {
  const raw = await redis.get(`machine:${id}`);
  return raw ? JSON.parse(raw) : null;
}

export async function resumeActor(id: string) {
  const snapshot = await loadSnapshot(id);
  const actor = createActor(codeReviewMachine, {
    snapshot: snapshot ?? undefined,
  });
  actor.subscribe(async (s) => saveSnapshot(id, s.getMeta()));
  actor.start();
  return actor;
}

// __tests__/code-review.test.ts
import { createActor } from "xstate";
import { codeReviewMachine } from "../lib/code-review-machine";

test("high-risk diff transitions to awaitingApproval", async () => {
  const actor = createActor(codeReviewMachine);
  actor.start();
  actor.send({
    type: "START",
    prDiff: "- password = getenv('DB_PASSWORD')\n+ password = '1234'",
    prUrl: "https://github.com/org/repo/pull/42",
  });

  // Wait for analysis to complete (mocked in tests)
  await new Promise((r) => setTimeout(r, 100));

  expect(actor.getSnapshot().value).toBe("awaitingApproval");
  expect(actor.getSnapshot().context.analysis?.riskLevel).toBe("high");
});

test("approval moves from awaitingApproval to posting", () => {
  const actor = createActor(codeReviewMachine, {
    // Inject pre-analyzed context
    snapshot: {
      value: "awaitingApproval",
      context: {
        analysis: { riskLevel: "high", summary: "...", issues: [], approved: false },
        prDiff: "",
        prUrl: "",
        approvalRequestedAt: new Date(),
        postedReviewId: null,
        error: null,
        retryCount: 0,
      },
    },
  });
  actor.start();
  actor.send({ type: "APPROVAL_GRANTED" });
  expect(actor.getSnapshot().value).toBe("posting");
});

import { inspect } from "@xstate/inspect";

if (process.env.NODE_ENV === "development") {
  inspect({ iframe: false }); // Opens in a new tab
}

const actor = createActor(codeReviewMachine, {
  inspect: true, // Connects to inspector
});