fifony 0.1.27 → 0.1.29

package/dist/chunk-2G6SRDOC.js

@@ -0,0 +1,847 @@
+import {
+  computeDiffStats
+} from "./chunk-XVF6GOVS.js";
+import {
+  isoWeek,
+  now
+} from "./chunk-O5AEQXUV.js";
+import {
+  logger
+} from "./chunk-DVU3CXWA.js";
+import {
+  S3DB_ISSUE_RESOURCE,
+  TERMINAL_STATES
+} from "./chunk-OONOOWNC.js";
+
+// src/agents/failure-analyzer.ts
+function extractFilePaths(output) {
+  const pathRegex = /(?:^|\s|["'(])([.\w/-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|css|html|vue|svelte))\b/gm;
+  const paths = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = pathRegex.exec(output)) !== null) {
+    const p = match[1];
+    if (p && !p.startsWith("http") && !p.includes("node_modules") && p.includes("/")) {
+      paths.add(p);
+    }
+  }
+  return [...paths].slice(0, 10);
+}
+function extractErrorLine(output) {
+  const patterns = [
+    // Specific error codes first (most informative)
+    /error\s+TS\d+:\s*(.+)/m,
+    /^AssertionError.*:\s*(.+)$/m,
+    /^CONFLICT\s*(.+)$/m,
+    /^fatal:\s*(.+)$/m,
+    /ERR!\s*(.+)$/m,
+    // Generic error types
+    /^(?:Error|TypeError|ReferenceError|SyntaxError|RangeError):\s*(.+)$/m,
+    /^(?:FAIL|FAILED)\s+(.+)$/m,
+    /^error:\s*(.+)$/m
+  ];
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match) return match[0].trim().slice(0, 200);
+  }
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length > 10 && /error|fail|cannot|unable|not found|unexpected/i.test(trimmed)) {
+      return trimmed.slice(0, 200);
+    }
+  }
+  return "";
+}
+function detectFailedCommand(output) {
+  const scriptMatch = output.match(/(?:pnpm|npm|yarn)\s+(?:run\s+)?(\w+).*(?:failed|error|ELIFECYCLE)/im) || output.match(/(?:pnpm|npm|yarn)\s+(\w+)\s+failed/im);
+  if (scriptMatch) return `pnpm ${scriptMatch[1]}`;
+  if (/error\s+TS\d+/m.test(output)) return "tsc (TypeScript compiler)";
+  if (/eslint/i.test(output) && /error/i.test(output)) return "eslint";
+  if (/jest|vitest|mocha|node --test/i.test(output) && /fail/i.test(output)) return "test runner";
+  if (/git\s+(merge|rebase|push|pull)/i.test(output) && /fatal|error|conflict/i.test(output)) {
+    const gitMatch = output.match(/git\s+(merge|rebase|push|pull)/i);
+    return gitMatch ? `git ${gitMatch[1]}` : "git";
+  }
+  if (/SIGTERM|SIGKILL|timed?\s*out/i.test(output)) return "process (timeout/killed)";
+  return void 0;
+}
+function unwrapJsonOutput(raw) {
+  try {
+    const parsed = JSON.parse(raw.trim());
+    if (typeof parsed === "object" && parsed !== null) {
+      if (typeof parsed.result === "string") return parsed.result;
+      if (typeof parsed.response === "string") return parsed.response;
+      if (parsed.structured_output?.summary) return String(parsed.structured_output.summary);
+    }
+  } catch {
+  }
+  return raw;
+}
+function extractFailureInsights(output, exitCode) {
+  const normalizedOutput = output ? `${unwrapJsonOutput(output)}
+${output}` : "";
+  let errorType = "unknown";
+  if (/error\s+TS\d+/m.test(normalizedOutput)) {
+    errorType = "typescript";
+  } else if (/eslint|ESLint/m.test(normalizedOutput) && /error/m.test(normalizedOutput)) {
+    errorType = "lint";
+  } else if (/(?:CONFLICT|Merge conflict)/im.test(normalizedOutput)) {
+    errorType = "git";
+  } else if (/(?:FAIL\s|AssertionError|test.*failed|expect.*received)/im.test(normalizedOutput)) {
+    errorType = "test";
+  } else if (/(?:SIGTERM|SIGKILL|timed?\s*out|killed)/im.test(normalizedOutput)) {
+    errorType = "timeout";
+  } else if (/(?:ELIFECYCLE|ERR!|build.*fail)/im.test(normalizedOutput)) {
+    errorType = "build";
+  } else if (/(?:fatal:\s)/m.test(normalizedOutput)) {
+    errorType = "git";
+  } else if (/(?:Error:|TypeError:|ReferenceError:|SyntaxError:)/m.test(normalizedOutput)) {
+    errorType = "runtime";
+  } else if (exitCode && exitCode !== 0) {
+    errorType = "process";
+  }
+  const errorMessage = extractErrorLine(normalizedOutput);
+  const failedCommand = detectFailedCommand(normalizedOutput);
+  const filesInvolved = extractFilePaths(normalizedOutput);
+  let rootCause;
+  switch (errorType) {
+    case "typescript":
+      rootCause = `TypeScript compilation failed${filesInvolved.length ? ` in ${filesInvolved[0]}` : ""}`;
+      break;
+    case "test":
+      rootCause = `Test assertion failed${filesInvolved.length ? ` in ${filesInvolved[0]}` : ""}`;
+      break;
+    case "lint":
+      rootCause = "Lint rules violated";
+      break;
+    case "timeout":
+      rootCause = "Process timed out or was killed";
+      break;
+    case "build":
+      rootCause = "Build/install step failed";
+      break;
+    case "git":
+      rootCause = "Git operation failed (possible conflict or dirty state)";
+      break;
+    case "runtime":
+      rootCause = `Runtime error: ${errorMessage.slice(0, 80)}`;
+      break;
+    case "process":
+      rootCause = `Process exited with code ${exitCode}`;
+      break;
+    default:
+      rootCause = errorMessage ? `Error: ${errorMessage.slice(0, 80)}` : "Unknown failure";
+  }
+  let suggestion;
+  switch (errorType) {
+    case "typescript":
+      suggestion = "Check type signatures and imports. The previous approach introduced a type error \u2014 try a different API surface.";
+      break;
+    case "test":
+      suggestion = "The implementation broke existing tests. Read the test file first, understand the expected behavior, then fix the implementation to match.";
+      break;
+    case "lint":
+      suggestion = "Run the linter before finishing. Fix formatting and rule violations.";
+      break;
+    case "timeout":
+      suggestion = "The previous approach was too slow or hung. Simplify the approach or break it into smaller steps.";
+      break;
+    case "build":
+      suggestion = "A dependency or build step failed. Check package.json and verify imports.";
+      break;
+    case "git":
+      suggestion = "A git operation failed. Check for merge conflicts, uncommitted changes, or branch state.";
+      break;
+    case "runtime":
+      suggestion = "The code threw an error at runtime. Check for null/undefined, missing imports, or wrong API usage.";
+      break;
+    default:
+      suggestion = "Review the full error output and try a fundamentally different approach.";
+  }
+  return {
+    errorType,
+    errorMessage,
+    failedCommand,
+    filesInvolved,
+    rootCause,
+    suggestion
+  };
+}
+
+// src/domains/metrics.ts
+function computeMetrics(issues) {
+  let planning = 0;
+  let queued = 0;
+  let inProgress = 0;
+  let blocked = 0;
+  let done = 0;
+  let merged = 0;
+  let cancelled = 0;
+  const completionTimes = [];
+  for (const issue of issues) {
+    if (issue.state === "Merged") {
+      const duration = issue.durationMs;
+      const candidate = typeof duration === "number" && Number.isFinite(duration) ? duration : Number.isFinite(Date.parse(issue.startedAt ?? "")) && Number.isFinite(Date.parse(issue.completedAt ?? "")) ? Date.parse(issue.completedAt) - Date.parse(issue.startedAt) : NaN;
+      if (Number.isFinite(candidate) && candidate >= 0) {
+        completionTimes.push(candidate);
+      }
+    }
+    switch (issue.state) {
+      case "Planning":
+        planning += 1;
+        break;
+      case "PendingApproval":
+        queued += 1;
+        break;
+      case "Queued":
+      case "Running":
+      case "Reviewing":
+      case "PendingDecision":
+        inProgress += 1;
+        break;
+      case "Blocked":
+        blocked += 1;
+        break;
+      case "Approved":
+        done += 1;
+        break;
+      case "Merged":
+        merged += 1;
+        break;
+      case "Cancelled":
+        cancelled += 1;
+        break;
+    }
+  }
+  if (completionTimes.length === 0) {
+    return {
+      total: issues.length,
+      planning,
+      queued,
+      inProgress,
+      blocked,
+      done,
+      merged,
+      cancelled,
+      activeWorkers: 0
+    };
+  }
+  const sortedCompletionTimes = completionTimes.slice().sort((a, b) => a - b);
+  const totalCompletionMs = sortedCompletionTimes.reduce((acc, value) => acc + value, 0);
+  const mid = Math.floor(sortedCompletionTimes.length / 2);
+  const medianCompletionMs = sortedCompletionTimes.length % 2 === 1 ? sortedCompletionTimes[mid] : Math.round((sortedCompletionTimes[mid - 1] + sortedCompletionTimes[mid]) / 2);
+  return {
+    total: issues.length,
+    planning,
+    queued,
+    inProgress,
+    blocked,
+    done,
+    merged,
+    cancelled,
+    activeWorkers: 0,
+    avgCompletionMs: Math.round(totalCompletionMs / completionTimes.length),
+    medianCompletionMs,
+    fastestCompletionMs: sortedCompletionTimes[0],
+    slowestCompletionMs: sortedCompletionTimes[sortedCompletionTimes.length - 1]
+  };
+}
+
+// src/persistence/metrics-cache.ts
+var cachedMetrics = null;
+var metricsStale = true;
+function invalidateMetrics() {
+  metricsStale = true;
+}
+function getMetrics(issues) {
+  if (!metricsStale && cachedMetrics) return cachedMetrics;
+  cachedMetrics = computeMetrics(issues);
+  metricsStale = false;
+  return cachedMetrics;
+}
+
+// src/persistence/dirty-tracker.ts
+var dirtyIssueIds = /* @__PURE__ */ new Set();
+var dirtyIssuePlanIds = /* @__PURE__ */ new Set();
+var dirtyEventIds = /* @__PURE__ */ new Set();
+function markIssueDirty(id) {
+  dirtyIssueIds.add(id);
+}
+function markIssuePlanDirty(id) {
+  dirtyIssuePlanIds.add(id);
+}
+function markEventDirty(id) {
+  dirtyEventIds.add(id);
+}
+function hasDirtyState() {
+  return dirtyIssueIds.size > 0 || dirtyEventIds.size > 0;
+}
+function getDirtyIssueIds() {
+  return dirtyIssueIds;
+}
+function getDirtyEventIds() {
+  return dirtyEventIds;
+}
+function snapshotAndClearDirtyIssueIds() {
+  const snapshot = new Set(dirtyIssueIds);
+  for (const id of snapshot) dirtyIssueIds.delete(id);
+  return snapshot;
+}
+function snapshotAndClearDirtyIssuePlanIds() {
+  const snapshot = new Set(dirtyIssuePlanIds);
+  for (const id of snapshot) dirtyIssuePlanIds.delete(id);
+  return snapshot;
+}
+function snapshotAndClearDirtyEventIds() {
+  const snapshot = new Set(dirtyEventIds);
+  for (const id of snapshot) dirtyEventIds.delete(id);
+  return snapshot;
+}
+function markAllIssuesDirty(ids) {
+  for (const id of ids) dirtyIssueIds.add(id);
+}
+function markAllIssuePlansDirty(ids) {
+  for (const id of ids) dirtyIssuePlanIds.add(id);
+}
+function markAllEventsDirty(ids) {
+  for (const id of ids) dirtyEventIds.add(id);
+}
+
+// src/persistence/plugins/issue-state-machine.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+var fsmEventEmitter = null;
+function setFsmEventEmitter(emitter) {
+  fsmEventEmitter = emitter;
+}
+function emitFsmEvent(issueId, kind, message) {
+  if (fsmEventEmitter) {
+    try {
+      fsmEventEmitter(issueId, kind, message);
+    } catch {
+    }
+  }
+}
+async function lazyEnqueue(issue, job) {
+  const { enqueue } = await import("./queue-workers-EGHCDDLB.js");
+  return enqueue(issue, job);
+}
+var ISSUE_STATE_MACHINE_ID = "issue-lifecycle";
+function markDirtyAndInvalidate(issueId) {
+  markIssueDirty(issueId);
+  invalidateMetrics();
+}
+function resolveIssue(context) {
+  return context.issue ?? null;
+}
+function issueResource(machine) {
+  return machine.database?.resources?.[S3DB_ISSUE_RESOURCE];
+}
+var STALE_TIMEOUT_MS = 24e5;
+async function isStaleIssue(context, _entityId) {
+  const issue = resolveIssue(context);
+  if (!issue) return false;
+  return Date.now() - Date.parse(issue.updatedAt) > STALE_TIMEOUT_MS;
+}
+var issueStateMachineConfig = {
+  persistTransitions: true,
+  workerId: `fifony-${process.pid}`,
+  lockTimeout: 5e3,
+  lockTTL: 30,
+  stateMachines: {
+    [ISSUE_STATE_MACHINE_ID]: {
+      resource: S3DB_ISSUE_RESOURCE,
+      stateField: "state",
+      initialState: "Planning",
+      autoCleanup: false,
+      states: {
+        Planning: {
+          on: { PLANNED: "PendingApproval", CANCEL: "Cancelled" },
+          entry: "onEnterPlanning"
+        },
+        PendingApproval: {
+          on: { QUEUE: "Queued", REPLAN: "Planning", CANCEL: "Cancelled" },
+          entry: "onEnterPendingApproval"
+        },
+        Queued: {
+          on: { RUN: "Running" },
+          entry: "onEnterQueued"
+        },
+        Running: {
+          on: { REVIEW: "Reviewing", REQUEUE: "Queued", BLOCK: "Blocked" },
+          guards: { BLOCK: "requireBlockReason" },
+          triggers: [{
+            type: "cron",
+            cron: "*/10 * * * *",
+            sendEvent: "BLOCK",
+            condition: isStaleIssue
+          }]
+        },
+        Reviewing: {
+          on: { REVIEWED: "PendingDecision", REQUEUE: "Queued", BLOCK: "Blocked" },
+          entry: "onEnterReviewing",
+          guards: { BLOCK: "requireBlockReason" },
+          triggers: [{
+            type: "cron",
+            cron: "*/10 * * * *",
+            sendEvent: "BLOCK",
+            condition: isStaleIssue
+          }]
+        },
+        PendingDecision: {
+          on: { APPROVE: "Approved", REQUEUE: "Queued", REPLAN: "Planning", CANCEL: "Cancelled" }
+        },
+        Blocked: {
+          on: { UNBLOCK: "Queued", REPLAN: "Planning", CANCEL: "Cancelled" },
+          entry: "onEnterBlocked"
+        },
+        Approved: {
+          on: { MERGE: "Merged", REOPEN: "Planning" },
+          entry: "onEnterApproved"
+        },
+        Merged: {
+          on: { ARCHIVE: "Archived", REOPEN: "Planning" },
+          type: "final",
+          entry: "onEnterMerged"
+        },
+        Cancelled: {
+          on: { ARCHIVE: "Archived", REOPEN: "Planning" },
+          type: "final",
+          entry: "onEnterCancelled"
+        },
+        Archived: {
+          on: {},
+          type: "final",
+          entry: "onEnterArchived"
+        }
+      }
+    }
+  },
+  // ── Actions: (context, event, machine) ──────────────────────────────────
+  // context = payload from send()
+  // event   = event name ("PLANNED", "BLOCK", etc.)
+  // machine = { database, machineId, entityId }
+  //
+  // Actions only mutate the in-memory issue + fire side effects (enqueue, s3db patch).
+  // Dirty tracking + metrics invalidation is done once in executeTransition() after send().
+  actions: {
+    onEnterPlanning: async (context, _event, _machine) => {
+      const issue = resolveIssue(context);
+      if (issue) {
+        issue.planningStatus = "idle";
+        issue.planningError = void 0;
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        emitFsmEvent(issue.id, "state", `${issue.identifier} entered Planning.`);
+        lazyEnqueue(issue, "plan").catch(() => {
+        });
+      }
+    },
+    onEnterPendingApproval: async (context, _event, _machine) => {
+      const issue = resolveIssue(context);
+      if (issue) {
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        emitFsmEvent(issue.id, "state", `Plan ready \u2014 ${issue.identifier} awaiting approval.`);
+      }
+    },
+    onEnterQueued: async (context, _event, _machine) => {
+      const issue = resolveIssue(context);
+      if (issue) {
+        if (issue.attempts > 0 && issue.lastError) {
+          let fullOutput = "";
+          let outputFile;
+          if (issue.workspacePath) {
+            try {
+              const outputsDir = join(issue.workspacePath, "outputs");
+              if (existsSync(outputsDir)) {
+                const files = readdirSync(outputsDir).filter((f) => f.endsWith(".stdout.log")).sort((a, b) => {
+                  try {
+                    return statSync(join(outputsDir, b)).mtimeMs - statSync(join(outputsDir, a)).mtimeMs;
+                  } catch {
+                    return 0;
+                  }
+                });
+                if (files.length > 0) {
+                  outputFile = files[0];
+                  try {
+                    fullOutput = readFileSync(join(outputsDir, files[0]), "utf8");
+                  } catch {
+                  }
+                }
+              }
+            } catch {
+            }
+          }
+          const analysisSource = fullOutput || issue.commandOutputTail || issue.lastError || "";
+          const failureInsight = extractFailureInsights(analysisSource, issue.commandExitCode);
+          const summary = {
+            planVersion: issue.planVersion ?? 1,
+            executeAttempt: issue.executeAttempt ?? 1,
+            phase: issue.lastFailedPhase ?? void 0,
+            error: failureInsight.rootCause || (issue.lastError ?? "").slice(0, 500),
+            outputTail: (issue.commandOutputTail ?? "").slice(0, 500),
+            outputFile,
+            timestamp: now(),
+            insight: {
+              errorType: failureInsight.errorType,
+              rootCause: failureInsight.rootCause,
+              failedCommand: failureInsight.failedCommand,
+              filesInvolved: failureInsight.filesInvolved,
+              suggestion: failureInsight.suggestion
+            }
+          };
+          const prev = issue.previousAttemptSummaries ?? [];
+          issue.previousAttemptSummaries = [...prev.slice(-2), summary].slice(-3);
+        }
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        issue.lastFailedPhase = void 0;
+        logger.info({ issueId: issue.id, identifier: issue.identifier }, "[FSM] onEnterQueued \u2014 enqueuing for execution");
+        emitFsmEvent(issue.id, "state", `${issue.identifier} queued for execution.`);
+        lazyEnqueue(issue, "execute").catch((err) => {
+          logger.error({ err, issueId: issue.id }, "[FSM] onEnterQueued \u2014 enqueue FAILED");
+        });
+      }
+    },
+    onEnterReviewing: async (context, _event, machine) => {
+      const issue = resolveIssue(context);
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      if (issue) {
+        issue.reviewingAt = ts;
+        issue.lastError = void 0;
+        emitFsmEvent(issue.id, "state", `${issue.identifier} moved to Reviewing.`);
+        lazyEnqueue(issue, "review").catch(() => {
+        });
+      }
+      const res = issueResource(machine);
+      if (res) {
+        res.patch(machine.entityId, { reviewingAt: ts }).catch(() => {
+        });
+      }
+    },
+    onEnterBlocked: async (context, _event, _machine) => {
+      const issue = resolveIssue(context);
+      const note = typeof context.note === "string" ? context.note : "Blocked";
+      if (issue) {
+        issue.lastError = note;
+        emitFsmEvent(issue.id, "error", `${issue.identifier} blocked: ${note}`);
+      }
+    },
+    onEnterApproved: async (context, _event, _machine) => {
+      const issue = resolveIssue(context);
+      if (issue) {
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        if (!issue.linesAdded && !issue.linesRemoved && issue.baseBranch && issue.branchName) {
+          computeDiffStats(issue);
+        }
+        emitFsmEvent(issue.id, "state", `${issue.identifier} approved \u2014 waiting for merge.`);
+      }
+    },
+    onEnterMerged: async (context, _event, machine) => {
+      const issue = resolveIssue(context);
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const week = isoWeek();
+      if (issue) {
+        if (!issue.linesAdded && !issue.linesRemoved && issue.baseBranch && issue.branchName) {
+          computeDiffStats(issue);
+        }
+        issue.completedAt = ts;
+        issue.terminalWeek = week;
+        if (!issue.mergedAt) issue.mergedAt = ts;
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        emitFsmEvent(issue.id, "state", `${issue.identifier} merged.`);
+      }
+      const res = issueResource(machine);
+      if (res) {
+        const churnAdded = issue?.linesAdded ?? 0;
+        const churnRemoved = issue?.linesRemoved ?? 0;
+        const churnFiles = issue?.filesChanged ?? 0;
+        if (churnAdded || churnRemoved || churnFiles) {
+          await res.patch(machine.entityId, { linesAdded: 0, linesRemoved: 0, filesChanged: 0 }).catch(() => {
+          });
+        }
+        await res.patch(machine.entityId, {
+          completedAt: ts,
+          terminalWeek: week,
+          mergedAt: issue?.mergedAt ?? ts,
+          nextRetryAt: void 0,
+          lastError: void 0,
+          linesAdded: churnAdded,
+          linesRemoved: churnRemoved,
+          filesChanged: churnFiles,
+          branchName: issue?.branchName,
+          workspacePath: issue?.workspacePath,
+          worktreePath: issue?.worktreePath,
+          mergedReason: issue?.mergedReason
+        }).catch(() => {
+        });
+        if (churnAdded || churnRemoved || churnFiles) {
+          logger.info({ issueId: issue?.id, linesAdded: churnAdded, linesRemoved: churnRemoved, filesChanged: churnFiles }, "[FSM] EC diff stats patched on merge (reset\u2192set for delta tracking)");
+        }
+      }
+    },
+    onEnterCancelled: async (context, _event, machine) => {
+      const issue = resolveIssue(context);
+      const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const week = isoWeek();
+      if (issue) {
+        issue.completedAt = ts;
+        issue.terminalWeek = week;
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        emitFsmEvent(issue.id, "state", `${issue.identifier} cancelled.`);
+      }
+      const res = issueResource(machine);
+      if (res) {
+        res.patch(machine.entityId, {
+          completedAt: ts,
+          terminalWeek: week,
+          nextRetryAt: void 0,
+          lastError: void 0,
+          cancelledReason: issue?.cancelledReason
+        }).catch(() => {
+        });
+      }
+    },
+    onEnterArchived: async (context, _event, _machine) => {
+      const issue = resolveIssue(context);
+      if (issue) {
+        emitFsmEvent(issue.id, "state", `${issue.identifier} archived.`);
+      }
+    }
+  },
+  // ── Guards: (context, event, machine) ───────────────────────────────────
+  guards: {
+    requireBlockReason: async (context, _event, _machine) => {
+      return typeof context.note === "string" && context.note.trim().length > 0;
+    }
+  }
+};
+var EVENT_TO_STATE = {
+  PLANNED: "PendingApproval",
+  QUEUE: "Queued",
+  RUN: "Running",
+  REVIEW: "Reviewing",
+  REVIEWED: "PendingDecision",
+  APPROVE: "Approved",
+  MERGE: "Merged",
+  CANCEL: "Cancelled",
+  BLOCK: "Blocked",
+  UNBLOCK: "Queued",
+  REPLAN: "Planning",
+  REQUEUE: "Queued",
+  REOPEN: "Planning",
+  ARCHIVE: "Archived"
+};
+function eventToTargetState(event) {
+  return EVENT_TO_STATE[event];
+}
+function getStatesFromConfig() {
+  const machine = issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID];
+  const result = {};
+  for (const [state, def] of Object.entries(machine.states)) {
+    result[state] = def.on ?? {};
+  }
+  return result;
+}
+function getStateMachineTransitions() {
+  const edges = getStatesFromConfig();
+  const result = {};
+  for (const [state, events] of Object.entries(edges)) {
+    const targets = [...new Set(Object.values(events))];
+    result[state] = targets;
+  }
+  return result;
+}
+function findIssueStateMachineTransitionPath(_machineDefinition, from, to) {
+  if (from === to) return [];
+  const edges = getStatesFromConfig();
+  if (!edges[from] || !edges[to]) return null;
+  const queue = [from];
+  const previousState = /* @__PURE__ */ new Map();
+  const previousEvent = /* @__PURE__ */ new Map();
+  previousState.set(from, "");
+  for (let i = 0; i < queue.length; i += 1) {
+    const current = queue[i];
+    const transitions = edges[current];
+    if (!transitions) continue;
+    for (const [evt, next] of Object.entries(transitions)) {
+      if (previousState.has(next)) continue;
+      previousState.set(next, current);
+      previousEvent.set(next, evt);
+      if (next === to) {
+        const events = [];
+        let cursor = next;
+        while (cursor !== from) {
+          const prev = previousState.get(cursor);
+          const e = previousEvent.get(cursor);
+          if (!prev || !e) return null;
+          events.unshift(e);
+          cursor = prev;
+        }
+        return events;
+      }
+      queue.push(next);
+    }
+  }
+  return null;
+}
+var issueResourceStateApi = null;
+function setIssueResourceStateApi(api) {
+  issueResourceStateApi = api;
+}
+function getIssueResourceStateApi() {
+  return issueResourceStateApi;
+}
+var issueStateMachinePlugin = null;
+function setIssueStateMachinePlugin(plugin) {
+  issueStateMachinePlugin = plugin;
+}
+function getIssueStateMachinePlugin() {
+  return issueStateMachinePlugin;
+}
+function getIssueStateMachineDefinition() {
+  return issueStateMachinePlugin?.getMachineDefinition?.(ISSUE_STATE_MACHINE_ID) ?? issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID];
+}
+function getIssueStateMachineInitialState() {
+  return issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID].initialState;
+}
+async function executeTransition(issue, event, context = {}) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const previous = issue.state;
+  const targetState = eventToTargetState(event);
+  if (!targetState) {
+    throw new Error(`Unknown FSM event '${event}' for issue ${issue.id}.`);
+  }
+  const resourceApi = getIssueResourceStateApi();
+  const plugin = getIssueStateMachinePlugin();
+  const sendContext = { ...context, issue };
+  if (resourceApi) {
+    try {
+      await resourceApi.send(issue.id, event, sendContext);
+    } catch (err) {
+      if (String(err).includes("not found") || String(err).includes("not initialized")) {
+        await resourceApi.initialize(issue.id, { issue, state: previous });
+        await resourceApi.send(issue.id, event, sendContext);
+      } else {
+        throw err;
+      }
+    }
+  } else if (plugin?.send) {
+    try {
+      await plugin.send(ISSUE_STATE_MACHINE_ID, issue.id, event, sendContext);
+    } catch (err) {
+      if (plugin.initializeEntity && String(err).includes("not found")) {
+        await plugin.initializeEntity(ISSUE_STATE_MACHINE_ID, issue.id, { issue, state: previous });
+        await plugin.send(ISSUE_STATE_MACHINE_ID, issue.id, event, sendContext);
+      } else {
+        throw err;
+      }
+    }
+  } else {
+    if (previous !== targetState) {
+      const edges = getStatesFromConfig();
+      const stateTransitions = edges[previous];
+      if (!stateTransitions || !stateTransitions[event]) {
+        throw new Error(`State machine does not allow event '${event}' from '${previous}' for issue ${issue.id}.`);
+      }
+    }
+    const stateDef = issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID].states[previous];
+    if (stateDef && "guards" in stateDef && stateDef.guards?.[event]) {
+      const guardName = stateDef.guards[event];
+      const guardFn = issueStateMachineConfig.guards[guardName];
+      if (guardFn) {
+        const allowed = await guardFn(sendContext, event, { database: null, machineId: ISSUE_STATE_MACHINE_ID, entityId: issue.id });
+        if (!allowed) {
+          throw new Error(`Guard '${guardName}' rejected event '${event}' for issue ${issue.id}.`);
+        }
+      }
+    }
+    const targetDef = issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID].states[targetState];
+    if (targetDef && "entry" in targetDef && typeof targetDef.entry === "string") {
+      const actionName = targetDef.entry;
+      const actionFn = issueStateMachineConfig.actions[actionName];
+      if (actionFn) {
+        await actionFn(sendContext, event, { database: null, machineId: ISSUE_STATE_MACHINE_ID, entityId: issue.id });
+      }
+    }
+  }
+  issue.state = targetState;
+  issue.updatedAt = ts;
+  const note = typeof context.note === "string" ? context.note : `${event}: ${previous} \u2192 ${targetState}`;
+  issue.history.push(`[${ts}] ${note}`);
+  if (TERMINAL_STATES.has(previous) && !TERMINAL_STATES.has(targetState)) {
+    issue.terminalWeek = "";
+  }
+  markDirtyAndInvalidate(issue.id);
+  return { previousState: previous };
+}
+async function getIssueTransitionHistory(issueId, options) {
+  const resourceApi = getIssueResourceStateApi();
+  if (resourceApi?.history) {
+    try {
+      return await resourceApi.history(issueId, options);
+    } catch {
+    }
+  }
+  const plugin = getIssueStateMachinePlugin();
+  if (plugin?.getTransitionHistory) {
+    try {
+      return await plugin.getTransitionHistory(ISSUE_STATE_MACHINE_ID, issueId, options);
+    } catch {
+    }
+  }
+  return [];
+}
+async function canTransitionIssue(issueId, event) {
+  const resourceApi = getIssueResourceStateApi();
+  if (resourceApi?.canTransition) {
+    try {
+      return await resourceApi.canTransition(issueId, event);
+    } catch {
+    }
+  }
+  return false;
+}
+function visualizeStateMachine() {
+  const plugin = getIssueStateMachinePlugin();
+  if (!plugin?.visualize) return null;
+  return plugin.visualize(ISSUE_STATE_MACHINE_ID);
+}
+
+export {
+  computeMetrics,
+  getMetrics,
+  markIssueDirty,
+  markIssuePlanDirty,
+  markEventDirty,
+  hasDirtyState,
+  getDirtyIssueIds,
+  getDirtyEventIds,
+  snapshotAndClearDirtyIssueIds,
+  snapshotAndClearDirtyIssuePlanIds,
+  snapshotAndClearDirtyEventIds,
+  markAllIssuesDirty,
+  markAllIssuePlansDirty,
+  markAllEventsDirty,
+  setFsmEventEmitter,
+  ISSUE_STATE_MACHINE_ID,
+  issueStateMachineConfig,
+  eventToTargetState,
+  getStateMachineTransitions,
+  findIssueStateMachineTransitionPath,
+  setIssueResourceStateApi,
+  getIssueResourceStateApi,
+  setIssueStateMachinePlugin,
+  getIssueStateMachinePlugin,
+  getIssueStateMachineDefinition,
+  getIssueStateMachineInitialState,
+  executeTransition,
+  getIssueTransitionHistory,
+  canTransitionIssue,
+  visualizeStateMachine
+};
+//# sourceMappingURL=chunk-2G6SRDOC.js.map