@h-rig/task-sources-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/control-plane/state-sync/reconcile.js

@@ -0,0 +1,260 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/state-sync/reconcile.ts
+var STALE_CLAIM_MS = 24 * 60 * 60 * 1000;
+function parseTimestamp(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function inProgressOwnershipMetadataIssue(metadata) {
+  if (!metadata?.claimId || !metadata.ownerId || !metadata.claimedAt || !metadata.lastEvidenceAt) {
+    return "missing-ownership-metadata";
+  }
+  if (parseTimestamp(metadata.claimedAt) == null || parseTimestamp(metadata.lastEvidenceAt) == null) {
+    return "invalid-ownership-timestamps";
+  }
+  return null;
+}
+function hasExplicitPullRequestEvidence(evidence) {
+  return evidence != null && Object.prototype.hasOwnProperty.call(evidence, "pr");
+}
+function hasPrCloseoutCompletionEvidence(evidence) {
+  const pr = evidence?.pr;
+  return evidence?.closeoutPassed === true && (pr?.isOpen === true || pr?.isMerged === true);
+}
+function isTaskClaimStale(metadata, nowIso) {
+  if (!metadata) {
+    return false;
+  }
+  const now = parseTimestamp(nowIso);
+  if (now == null) {
+    return false;
+  }
+  const reference = parseTimestamp(metadata.lastEvidenceAt) ?? parseTimestamp(metadata.claimedAt);
+  if (reference == null) {
+    return false;
+  }
+  return now - reference > STALE_CLAIM_MS;
+}
+function projectTaskReconciliation(input) {
+  const reasons = [];
+  const nowIso = input.evidence?.now ?? new Date().toISOString();
+  const isStale = isTaskClaimStale(input.metadata, nowIso);
+  const pr = input.evidence?.pr ?? null;
+  const hasExplicitPrEvidence = hasExplicitPullRequestEvidence(input.evidence);
+  const activeOwnerIds = (input.evidence?.activeOwnerIds ?? []).filter(Boolean);
+  if (new Set(activeOwnerIds).size > 1) {
+    return {
+      valid: false,
+      reasons: ["multiple-active-owners"],
+      isStale,
+      wouldReconcileTo: null,
+      nextMetadata: input.metadata
+    };
+  }
+  if (input.lifecycleStatus === "blocked" || input.lifecycleStatus === "cancelled") {
+    return {
+      valid: true,
+      reasons,
+      isStale,
+      wouldReconcileTo: null,
+      nextMetadata: input.metadata
+    };
+  }
+  if (input.lifecycleStatus === "in_progress") {
+    const ownershipMetadataIssue = inProgressOwnershipMetadataIssue(input.metadata);
+    const hasOwnershipMetadata = ownershipMetadataIssue == null;
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: hasOwnershipMetadata,
+        reasons: hasOwnershipMetadata ? reasons : [ownershipMetadataIssue],
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : {
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        }
+      };
+    }
+    if (ownershipMetadataIssue) {
+      return {
+        valid: false,
+        reasons: [ownershipMetadataIssue],
+        isStale,
+        wouldReconcileTo: pr?.isOpen ? "under_review" : "ready",
+        nextMetadata: pr?.isOpen ? {
+          ...input.metadata ?? { status: "under_review" },
+          status: "under_review",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : null
+      };
+    }
+    if (isStale) {
+      if (pr?.isOpen) {
+        return {
+          valid: false,
+          reasons: ["stale-claim"],
+          isStale,
+          wouldReconcileTo: "under_review",
+          nextMetadata: {
+            ...input.metadata,
+            status: "under_review",
+            lastEvidenceAt: nowIso,
+            ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+            ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+            ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+          }
+        };
+      }
+      return {
+        valid: false,
+        reasons: ["stale-claim"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+  }
+  if (hasPrCloseoutCompletionEvidence(input.evidence) && (input.lifecycleStatus === "open" || input.lifecycleStatus === "ready" || input.lifecycleStatus === "queued")) {
+    return {
+      valid: false,
+      reasons: ["pr-closeout-before-completion"],
+      isStale,
+      wouldReconcileTo: "completed",
+      nextMetadata: {
+        ...input.metadata ?? { status: "completed" },
+        status: "completed",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  if (input.lifecycleStatus === "under_review") {
+    const hasPrLink = Boolean(input.metadata?.prNumber || input.metadata?.prUrl || pr?.prNumber || pr?.prUrl);
+    if (!hasPrLink) {
+      return {
+        valid: false,
+        reasons: ["missing-pr-metadata"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+    if (hasExplicitPrEvidence && !pr) {
+      return {
+        valid: false,
+        reasons: ["missing-pr-evidence"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+    if (pr?.reviewState === "changes_requested") {
+      const ownershipMetadataIssue = inProgressOwnershipMetadataIssue(input.metadata);
+      if (ownershipMetadataIssue) {
+        return {
+          valid: false,
+          reasons: [ownershipMetadataIssue],
+          isStale,
+          wouldReconcileTo: "ready",
+          nextMetadata: null
+        };
+      }
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "in_progress",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "in_progress",
+          lastEvidenceAt: nowIso,
+          reviewState: "changes_requested"
+        } : null
+      };
+    }
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : null
+      };
+    }
+    if (pr && !pr.isOpen && !pr.isMerged) {
+      return {
+        valid: false,
+        reasons: ["closed-pr-without-merge"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+  }
+  if (input.lifecycleStatus === "completed" && pr?.isOpen && !hasPrCloseoutCompletionEvidence(input.evidence)) {
+    return {
+      valid: false,
+      reasons: ["completed-with-open-pr"],
+      isStale,
+      wouldReconcileTo: "under_review",
+      nextMetadata: {
+        ...input.metadata ?? { status: "under_review" },
+        status: "under_review",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  if (pr?.isOpen && (input.lifecycleStatus === "draft" || input.lifecycleStatus === "open" || input.lifecycleStatus === "ready" || input.lifecycleStatus === "queued" || input.lifecycleStatus === "in_progress")) {
+    return {
+      valid: true,
+      reasons,
+      isStale,
+      wouldReconcileTo: "under_review",
+      nextMetadata: {
+        ...input.metadata ?? { status: "under_review" },
+        status: "under_review",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  return {
+    valid: true,
+    reasons,
+    isStale,
+    wouldReconcileTo: null,
+    nextMetadata: input.metadata
+  };
+}
+export {
+  projectTaskReconciliation,
+  isTaskClaimStale
+};

package/dist/src/control-plane/state-sync/repo.d.ts

@@ -0,0 +1 @@
+export declare function resolveTrackerRepoPath(projectRoot: string): string;

package/dist/src/control-plane/state-sync/repo.js

@@ -0,0 +1,42 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/state-sync/repo.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+// packages/task-sources-plugin/src/control-plane/native/utils.ts
+import { getScopeRules } from "@rig/core/scope-rules";
+import { unique } from "@rig/core/exec";
+import {
+  runCapture,
+  runCaptureAsync,
+  runInherit,
+  getValidationTimeoutMs,
+  readJsonFile,
+  nowIso,
+  unique as unique2,
+  fileLines
+} from "@rig/core/exec";
+import { resolveCheckoutRoot } from "@rig/core/checkout-root";
+import { resolveHarnessPaths } from "@rig/core/harness-paths";
+var scopeRegexCache = new Map;
+
+// packages/task-sources-plugin/src/control-plane/state-sync/repo.ts
+import { MANAGED_REPO_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { getInstalledCapability } from "@rig/core/capability-loaders";
+function resolveTrackerRepoPath(projectRoot) {
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const managedRepos = getInstalledCapability(defineCapability(MANAGED_REPO_SERVICE_CAPABILITY));
+  if (managedRepos) {
+    try {
+      const layout = managedRepos.resolveMonorepoRepoLayout(projectRoot);
+      if (existsSync(resolve(layout.mirrorRoot, "HEAD"))) {
+        return layout.mirrorRoot;
+      }
+    } catch {}
+  }
+  return monorepoRoot;
+}
+export {
+  resolveTrackerRepoPath
+};

package/dist/src/control-plane/state-sync/types.d.ts

@@ -0,0 +1,28 @@
+export type CanonicalTaskLifecycleStatus = "draft" | "open" | "ready" | "queued" | "in_progress" | "under_review" | "blocked" | "completed" | "cancelled";
+export type TaskStateMetadata = {
+    claimId?: string;
+    status: CanonicalTaskLifecycleStatus;
+    ownerId?: string;
+    claimedAt?: string;
+    lastEvidenceAt?: string;
+    runId?: string;
+    branchName?: string;
+    prNumber?: number;
+    prUrl?: string;
+    reviewState?: string;
+    blockerReason?: string;
+    sourceCommit?: string;
+};
+export type TaskStateMetadataEnvelope = {
+    schemaVersion: number;
+    supported: boolean;
+    baseTrackerCommit: string | null;
+    tasks: Record<string, TaskStateMetadata>;
+};
+export declare function normalizeTaskLifecycleStatus(status: unknown): CanonicalTaskLifecycleStatus | null;
+export declare function discardMismatchedTaskStateMetadata(input: {
+    taskId: string;
+    lifecycleStatus: CanonicalTaskLifecycleStatus | null;
+    metadata: unknown;
+}): TaskStateMetadata | null;
+export declare function readTaskStateMetadataEnvelope(raw: unknown): TaskStateMetadataEnvelope;

package/dist/src/control-plane/state-sync/types.js

@@ -0,0 +1,111 @@
+// @bun
+// packages/task-sources-plugin/src/control-plane/state-sync/types.ts
+var SUPPORTED_TASK_STATE_SCHEMA_VERSION = 1;
+var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "completed",
+  "cancelled"
+]);
+function normalizeTaskLifecycleStatus(status) {
+  switch (status) {
+    case "draft":
+    case "open":
+    case "ready":
+    case "queued":
+    case "in_progress":
+    case "under_review":
+    case "blocked":
+    case "completed":
+    case "cancelled":
+      return status;
+    case "closed":
+      return "completed";
+    case "running":
+      return "in_progress";
+    case "failed":
+      return "ready";
+    default:
+      return null;
+  }
+}
+function normalizeTaskStateMetadataStatus(status) {
+  if (CANONICAL_TASK_LIFECYCLE_STATUSES.has(status)) {
+    return status;
+  }
+  switch (status) {
+    case "closed":
+      return "completed";
+    case "running":
+      return "in_progress";
+    case "failed":
+      return "ready";
+    default:
+      return;
+  }
+}
+function canonicalizeTaskStateMetadata(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const metadata = raw;
+  const claimId = typeof metadata.claimId === "string" && metadata.claimId.length > 0 ? metadata.claimId : undefined;
+  const status = normalizeTaskStateMetadataStatus(metadata.status);
+  if (!status) {
+    return null;
+  }
+  return {
+    ...claimId ? { claimId } : {},
+    status,
+    ...typeof metadata.ownerId === "string" && metadata.ownerId.length > 0 ? { ownerId: metadata.ownerId } : {},
+    ...typeof metadata.claimedAt === "string" && metadata.claimedAt.length > 0 ? { claimedAt: metadata.claimedAt } : {},
+    ...typeof metadata.lastEvidenceAt === "string" && metadata.lastEvidenceAt.length > 0 ? { lastEvidenceAt: metadata.lastEvidenceAt } : {},
+    ...typeof metadata.runId === "string" && metadata.runId.length > 0 ? { runId: metadata.runId } : {},
+    ...typeof metadata.branchName === "string" && metadata.branchName.length > 0 ? { branchName: metadata.branchName } : {},
+    ...typeof metadata.prNumber === "number" ? { prNumber: metadata.prNumber } : {},
+    ...typeof metadata.prUrl === "string" && metadata.prUrl.length > 0 ? { prUrl: metadata.prUrl } : {},
+    ...typeof metadata.reviewState === "string" && metadata.reviewState.length > 0 ? { reviewState: metadata.reviewState } : {},
+    ...typeof metadata.blockerReason === "string" && metadata.blockerReason.length > 0 ? { blockerReason: metadata.blockerReason } : {},
+    ...typeof metadata.sourceCommit === "string" && metadata.sourceCommit.length > 0 ? { sourceCommit: metadata.sourceCommit } : {}
+  };
+}
+function discardMismatchedTaskStateMetadata(input) {
+  input.taskId;
+  const canonicalMetadata = canonicalizeTaskStateMetadata(input.metadata);
+  if (!canonicalMetadata || !input.lifecycleStatus) {
+    return null;
+  }
+  const metadataStatus = canonicalMetadata.status ?? null;
+  if (metadataStatus && metadataStatus !== input.lifecycleStatus) {
+    return null;
+  }
+  return canonicalMetadata;
+}
+function readTaskStateMetadataEnvelope(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { schemaVersion: SUPPORTED_TASK_STATE_SCHEMA_VERSION, supported: true, baseTrackerCommit: null, tasks: {} };
+  }
+  const envelope = raw;
+  const schemaVersion = typeof envelope.schemaVersion === "number" ? envelope.schemaVersion : SUPPORTED_TASK_STATE_SCHEMA_VERSION;
+  if (schemaVersion !== SUPPORTED_TASK_STATE_SCHEMA_VERSION) {
+    return { schemaVersion, supported: false, baseTrackerCommit: null, tasks: {} };
+  }
+  const rawTasks = envelope.tasks && typeof envelope.tasks === "object" && !Array.isArray(envelope.tasks) ? envelope.tasks : {};
+  const tasks = Object.fromEntries(Object.entries(rawTasks).map(([taskId, metadata]) => [taskId, canonicalizeTaskStateMetadata(metadata)]).filter((entry) => entry[1] != null));
+  return {
+    schemaVersion,
+    supported: true,
+    baseTrackerCommit: typeof envelope.baseTrackerCommit === "string" && envelope.baseTrackerCommit.length > 0 ? envelope.baseTrackerCommit : null,
+    tasks
+  };
+}
+export {
+  readTaskStateMetadataEnvelope,
+  normalizeTaskLifecycleStatus,
+  discardMismatchedTaskStateMetadata
+};

package/dist/src/control-plane/state-sync/write.d.ts

@@ -0,0 +1,83 @@
+import { nativeFetchRef, nativePushRefWithLease, nativeReadBlobAtRef, nativeWriteTreeCommit } from "./native-git";
+import { readSyncedTrackerState, type SyncedTrackerSnapshot } from "./read";
+import { type TrackerReconcileEvidence } from "./reconcile";
+import { type CanonicalTaskLifecycleStatus, type TaskStateMetadata, type TaskStateMetadataEnvelope } from "./types";
+type WritableTrackerIssue = Record<string, unknown>;
+export type WritableTrackerState = {
+    repoPath: string;
+    baseOid: string;
+    issuesBaseOid: string;
+    taskStateBaseOid: string;
+    issueRows: WritableTrackerIssue[];
+    taskStateEnvelope: TaskStateMetadataEnvelope;
+};
+type TrackerWriterDeps = {
+    fetchRef: typeof nativeFetchRef;
+    readBlobAtRef: typeof nativeReadBlobAtRef;
+    writeTreeCommit: typeof nativeWriteTreeCommit;
+    pushRefWithLease: typeof nativePushRefWithLease;
+    readSnapshot: typeof readSyncedTrackerState;
+    createClaimId: () => string;
+    now: () => string;
+};
+export declare class TrackerStateMutationError extends Error {
+    readonly code: "same-base-required" | "task-not-found" | "invalid-task-status" | "status-conflict" | "claim-conflict" | "push-conflict" | "invalid-reconciliation";
+    constructor(message: string, code: "same-base-required" | "task-not-found" | "invalid-task-status" | "status-conflict" | "claim-conflict" | "push-conflict" | "invalid-reconciliation");
+}
+export declare function assertWritableTrackerStateBases(state: {
+    issuesBaseOid: string;
+    taskStateBaseOid: string;
+}): void;
+export declare function prepareClaimTaskMutation(state: WritableTrackerState, input: {
+    taskId: string;
+    ownerId: string;
+    runId?: string;
+    branchName?: string;
+    expectedStatus?: CanonicalTaskLifecycleStatus;
+    now: string;
+    claimId: string;
+}): WritableTrackerState;
+export declare function prepareLifecycleTaskMutation(state: WritableTrackerState, input: {
+    taskId: string;
+    status: CanonicalTaskLifecycleStatus;
+    allowedFrom?: CanonicalTaskLifecycleStatus[];
+    metadata?: TaskStateMetadata | null;
+    clearMetadata?: boolean;
+}): WritableTrackerState;
+export declare function prepareReconcileTaskMutation(state: WritableTrackerState, input: {
+    taskId: string;
+    evidence?: TrackerReconcileEvidence;
+}): WritableTrackerState | null;
+export declare function claimRemoteTrackerTask(projectRoot: string, input: {
+    taskId: string;
+    ownerId: string;
+    runId?: string;
+    branchName?: string;
+    expectedStatus?: CanonicalTaskLifecycleStatus;
+}, deps?: Partial<TrackerWriterDeps>): {
+    outcome: "applied" | "noop";
+    snapshot: SyncedTrackerSnapshot;
+    claimId: string;
+    commitOid: string | null;
+};
+export declare function reconcileRemoteTrackerTask(projectRoot: string, input: {
+    taskId: string;
+    evidence?: TrackerReconcileEvidence;
+}, deps?: Partial<TrackerWriterDeps>): {
+    outcome: "applied" | "noop";
+    snapshot: SyncedTrackerSnapshot;
+    commitOid: string | null;
+};
+export declare function updateRemoteTrackerTaskLifecycle(projectRoot: string, input: {
+    taskId: string;
+    status: CanonicalTaskLifecycleStatus;
+    allowedFrom?: CanonicalTaskLifecycleStatus[];
+    metadata?: TaskStateMetadata | null;
+    clearMetadata?: boolean;
+    reason?: string;
+}, deps?: Partial<TrackerWriterDeps>): {
+    outcome: "applied" | "noop";
+    snapshot: SyncedTrackerSnapshot;
+    commitOid: string | null;
+};
+export {};