@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-HXIIEMGF.js

@@ -0,0 +1,78 @@
+import {
+  emitResolutionWarningOnce,
+  resolveFastModel,
+  resolveProviderModel
+} from "./chunk-C3DH3NCY.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+
+// src/core/config/model-roles.ts
+var RETIRED_MODEL_ROLES = Object.freeze({
+  quality: "default",
+  reasoning: "default",
+  long_context: "default",
+  frontier: "default",
+  orchestrator: "default",
+  reviewer: "default",
+  implementation: "default",
+  cost: "fast"
+});
+function retiredModelRoleReplacement(role) {
+  const name = role.trim();
+  return Object.hasOwn(RETIRED_MODEL_ROLES, name) ? RETIRED_MODEL_ROLES[name] : void 0;
+}
+function resolveModelRoleModel(provider, role, options = {}) {
+  const { cwd = process.cwd(), registry } = options;
+  const name = role.trim();
+  if (name === "default") {
+    return { ...resolveProviderModel(provider, void 0, cwd), role: name, slot: "default" };
+  }
+  if (name === "fast") {
+    const { slot, ...fast } = resolveFastModel(provider, { cwd, registry });
+    return { ...fast, role: name, slot: slot === "default" ? "default" : "fast" };
+  }
+  const declared = ProviderRegistry.getModelForRole(provider, name, registry);
+  if (declared) {
+    return {
+      value: declared,
+      source: "registry",
+      sourcePath: `providers.yaml#providers.${provider}.models.roles.${name}`,
+      role: name,
+      slot: "role"
+    };
+  }
+  const replacement = retiredModelRoleReplacement(name);
+  if (!replacement) return void 0;
+  if (options.configPath) warnRetiredModelRole(provider, name, replacement, options);
+  return resolveModelRoleModel(provider, replacement, { cwd, registry });
+}
+function warnRetiredModelRole(provider, role, replacement, { configPath, modelKey }) {
+  const fix = replacement === "fast" ? `Set ${configPath} to 'fast'.` : modelKey ? `Set ${modelKey} to a model id or remove ${configPath}.` : `Remove ${configPath}.`;
+  emitResolutionWarningOnce({
+    operation: "retiredModelRole",
+    provider,
+    source: `${configPath}=${role}`,
+    message: `${configPath} '${role}' is retired; it now runs ${provider}'s ${replacement} model. ${fix}`
+  });
+}
+function resolveRoleSlotModel(provider, modelRole, options = {}) {
+  const resolved = resolveModelRoleModel(provider, modelRole.value, options);
+  if (!resolved) return void 0;
+  const { value, source, sourcePath, role, slot } = resolved;
+  if (slot === "default" || source !== "registry") return { value, source, sourcePath, role };
+  return {
+    value,
+    source: modelRole.source,
+    sourcePath: `${sourcePath} (via ${modelRole.sourcePath ?? modelRole.source})`,
+    role
+  };
+}
+
+export {
+  RETIRED_MODEL_ROLES,
+  retiredModelRoleReplacement,
+  resolveModelRoleModel,
+  resolveRoleSlotModel
+};
+//# sourceMappingURL=chunk-HXIIEMGF.js.map

package/dist/chunk-I56TH7VM.js

@@ -0,0 +1,46 @@
+// src/constants/timeouts.ts
+var MAX_VARIANT_EXECUTION_MS = 27e5;
+var DEFAULT_PER_VARIANT_TIMEOUT_MINUTES = 45;
+var MAX_PER_VARIANT_TIMEOUT_MINUTES = 720;
+function minutesToExecutorTimeoutMs(timeoutMinutes) {
+  if (typeof timeoutMinutes !== "number" || !Number.isFinite(timeoutMinutes) || timeoutMinutes <= 0) {
+    return void 0;
+  }
+  return Math.min(Math.floor(timeoutMinutes), MAX_PER_VARIANT_TIMEOUT_MINUTES) * 6e4;
+}
+var DEFAULT_TIMEOUT_MS = MAX_VARIANT_EXECUTION_MS;
+var DEFAULT_REPAIR_LOOP_MAX_ITERATIONS = 3;
+var DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_SECONDS = 120;
+var DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_MS = DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_SECONDS * 1e3;
+var GIT_OPERATION_MAX_RETRIES = 3;
+var GIT_COMMAND_TIMEOUT_MS = 1e4;
+var GIT_HOOK_COMMIT_TIMEOUT_MS = 6e5;
+var PLANNING_GIT_NETWORK_TIMEOUT_MS = 3e5;
+var PLANNING_STORAGE_FETCH_TIMEOUT_MS = 1e4;
+var PLANNING_STORAGE_PUSH_TIMEOUT_MS = 6e4;
+var GIT_WORKTREE_REMOVE_TIMEOUT_MS = 1e4;
+var RETRY_INITIAL_DELAY_MS = 100;
+var RETRY_MAX_DELAY_MS = 1e4;
+var RESOURCE_ACQUISITION_TIMEOUT_MS = 6e4;
+
+export {
+  MAX_VARIANT_EXECUTION_MS,
+  DEFAULT_PER_VARIANT_TIMEOUT_MINUTES,
+  MAX_PER_VARIANT_TIMEOUT_MINUTES,
+  minutesToExecutorTimeoutMs,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_REPAIR_LOOP_MAX_ITERATIONS,
+  DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_SECONDS,
+  DEFAULT_REPAIR_LOOP_ITERATION_TIMEOUT_MS,
+  GIT_OPERATION_MAX_RETRIES,
+  GIT_COMMAND_TIMEOUT_MS,
+  GIT_HOOK_COMMIT_TIMEOUT_MS,
+  PLANNING_GIT_NETWORK_TIMEOUT_MS,
+  PLANNING_STORAGE_FETCH_TIMEOUT_MS,
+  PLANNING_STORAGE_PUSH_TIMEOUT_MS,
+  GIT_WORKTREE_REMOVE_TIMEOUT_MS,
+  RETRY_INITIAL_DELAY_MS,
+  RETRY_MAX_DELAY_MS,
+  RESOURCE_ACQUISITION_TIMEOUT_MS
+};
+//# sourceMappingURL=chunk-I56TH7VM.js.map

package/dist/chunk-I6FN3R5D.js

@@ -0,0 +1,352 @@
+import {
+  repairDuplicatedProviderSegment
+} from "./chunk-GZK62I3N.js";
+
+// src/core/synthesis/derive-synthesis-value.ts
+var SYNTHESIS_FAILED_STATUSES = /* @__PURE__ */ new Set([
+  "gate_failed",
+  "generation_failed",
+  "timed_out",
+  "editable_workspace_unavailable"
+]);
+var NOVELTY_CARRY_FORWARD_THRESHOLD = 0.02;
+function deriveSynthesisValue(input) {
+  const donorHunksAccepted = readHarvestCount(input, "acceptedHunkCount");
+  const donorHunksRejected = readHarvestCount(input, "rejectedHunkCount");
+  const donorHunksConsidered = readHarvestCount(input, "consideredHunkCount");
+  const baseVariant = resolveBaseVariant(input);
+  const contributingVariants = normalizeVariantList(input.contributingVariants);
+  const noveltyScore = readFiniteNumber(input.noveltyScore);
+  const gateSummary = resolveGateSummary(input);
+  const outcomeStatus = normalizeOutcomeStatus(input.synthesisOutcomeStatus);
+  const label = classifySynthesisValue({
+    input,
+    outcomeStatus,
+    donorHunksAccepted,
+    donorHunksRejected,
+    donorHunksConsidered,
+    baseVariant,
+    contributingVariants,
+    noveltyScore,
+    gateSummary
+  });
+  return {
+    label,
+    baseVariant,
+    donorHunksAccepted,
+    donorHunksRejected,
+    donorHunksConsidered,
+    contributingVariants,
+    noveltyScore,
+    failureKind: label === "synthesis_failed" ? resolveFailureKind(outcomeStatus) : null,
+    gateSummary
+  };
+}
+function formatSynthesisValueRunSummaryLine(projection) {
+  const parts = [`synthesisValue: ${projection.label}`];
+  if (projection.baseVariant) {
+    parts.push(`base=${projection.baseVariant}`);
+  }
+  if (projection.donorHunksAccepted !== null) {
+    parts.push(`donor hunks accepted=${projection.donorHunksAccepted}`);
+  }
+  if (projection.gateSummary) {
+    parts.push(`gates=${projection.gateSummary}`);
+  }
+  return parts.join(", ");
+}
+function deriveSynthesisValueFromMergedResult(mergedResult) {
+  if (!mergedResult) return null;
+  return deriveSynthesisValue({
+    synthesisOutcomeStatus: mergedResult.synthesisOutcomeStatus,
+    synthesisApplied: mergedResult.synthesisApplied,
+    winnerFallback: mergedResult.winnerFallback,
+    winnerClone: mergedResult.winnerClone,
+    success: mergedResult.success,
+    deliverySucceeded: mergedResult.deliverySucceeded,
+    gatesPassed: mergedResult.gatesPassed,
+    noveltyScore: mergedResult.noveltyScore,
+    contributingVariants: mergedResult.contributingVariants,
+    mergedVariants: mergedResult.mergedVariants,
+    inputVariants: mergedResult.inputVariants,
+    harvestManifest: mergedResult.harvestManifest,
+    donorMaterialDiagnostic: mergedResult.donorMaterialDiagnostic,
+    synthesisGateResults: mergedResult.synthesisGateResults,
+    gateFailureDetails: mergedResult.gateFailureDetails,
+    error: mergedResult.error
+  });
+}
+function deriveSynthesisValueFromArtifactSummary(artifact) {
+  if (!artifact) return null;
+  const hasHarvestCounts = artifact.donorHunksAccepted != null || artifact.donorHunksRejected != null || artifact.donorHunksConsidered != null;
+  const harvestManifest = hasHarvestCounts ? {
+    baseWinner: { variantId: artifact.mergedVariants?.[0] ?? "unknown" },
+    entries: [],
+    summary: {
+      acceptedHunkCount: artifact.donorHunksAccepted ?? 0,
+      rejectedHunkCount: artifact.donorHunksRejected ?? 0,
+      consideredHunkCount: artifact.donorHunksConsidered ?? 0,
+      needsReviewHunkCount: 0,
+      appliedHunkCount: 0,
+      byReasonCode: {},
+      byFileKind: {}
+    }
+  } : void 0;
+  return deriveSynthesisValue({
+    synthesisOutcomeStatus: artifact.synthesisOutcomeStatus ?? void 0,
+    synthesisApplied: artifact.synthesisApplied ?? void 0,
+    winnerFallback: artifact.winnerFallback ?? void 0,
+    winnerClone: artifact.winnerClone ?? void 0,
+    success: artifact.success ?? void 0,
+    deliverySucceeded: artifact.deliverySucceeded ?? void 0,
+    gatesPassed: artifact.gatesPassed ?? void 0,
+    noveltyScore: artifact.noveltyScore ?? void 0,
+    contributingVariants: artifact.contributingVariants,
+    mergedVariants: artifact.mergedVariants,
+    harvestManifest,
+    synthesisGateResults: artifact.synthesisGateResults ?? void 0,
+    gateFailureDetails: isGateFailureDetails(artifact.gateFailureDetails) ? artifact.gateFailureDetails : void 0,
+    error: artifact.error ?? void 0
+  });
+}
+function deriveSynthesisValueFromArtifactOrSummary(rawArtifact, summary) {
+  return deriveSynthesisValueFromArtifact(rawArtifact) ?? deriveSynthesisValueFromArtifactSummary(summary);
+}
+function deriveSynthesisValueFromArtifact(artifact) {
+  if (!artifact) return null;
+  const declaredWinner = typeof artifact.declaredWinner === "object" && artifact.declaredWinner !== null ? artifact.declaredWinner : void 0;
+  return deriveSynthesisValue({
+    synthesisOutcomeStatus: readString(artifact.synthesisOutcomeStatus),
+    synthesisApplied: readBoolean(artifact.synthesisApplied),
+    winnerFallback: readBoolean(artifact.winnerFallback),
+    winnerClone: readBoolean(artifact.winnerClone),
+    success: readBoolean(artifact.success),
+    deliverySucceeded: readBoolean(artifact.deliverySucceeded),
+    gatesPassed: readBoolean(artifact.gatesPassed),
+    noveltyScore: readFiniteNumber(artifact.noveltyScore) ?? void 0,
+    contributingVariants: readStringArray(artifact.contributingVariants),
+    mergedVariants: readStringArray(artifact.mergedVariants),
+    inputVariants: readStringArray(artifact.inputVariants),
+    harvestManifest: isHarvestManifest(artifact.harvestManifest) ? artifact.harvestManifest : void 0,
+    donorMaterialDiagnostic: isDonorMaterialDiagnostic(artifact.donorMaterialDiagnostic) ? artifact.donorMaterialDiagnostic : void 0,
+    synthesisGateResults: isSynthesisGateResultSnapshot(artifact.synthesisGateResults) ? artifact.synthesisGateResults : isSynthesisGateResultSnapshot(artifact.gateResults) ? artifact.gateResults : void 0,
+    gateFailureDetails: isGateFailureDetails(artifact.gateFailureDetails) ? artifact.gateFailureDetails : void 0,
+    declaredWinner,
+    donorSelectionDecisions: readDonorSelectionDecisions(artifact.donorSelectionDecisions),
+    error: readString(artifact.error)
+  });
+}
+function classifySynthesisValue(params) {
+  const {
+    input,
+    outcomeStatus,
+    donorHunksAccepted,
+    donorHunksRejected,
+    donorHunksConsidered,
+    baseVariant,
+    contributingVariants,
+    noveltyScore,
+    gateSummary
+  } = params;
+  if (isSynthesisFailed(input, outcomeStatus)) {
+    return "synthesis_failed";
+  }
+  const acceptedDonorHunks = donorHunksAccepted ?? 0;
+  const hasAcceptedDonorMaterial = acceptedDonorHunks > 0 || hasNonBaseContributingVariants(baseVariant, contributingVariants);
+  if (hasAcceptedDonorMaterial && synthesisProducedUsableOutput(input, outcomeStatus, gateSummary)) {
+    return "donor_merge";
+  }
+  if (isWinnerRepair(input, outcomeStatus, acceptedDonorHunks, noveltyScore, gateSummary)) {
+    return "winner_repair";
+  }
+  if (isDonorRejection(donorHunksConsidered, donorHunksRejected, acceptedDonorHunks, input)) {
+    return "donor_rejection";
+  }
+  return "winner_carry_forward";
+}
+function isSynthesisFailed(input, outcomeStatus) {
+  if (outcomeStatus && SYNTHESIS_FAILED_STATUSES.has(outcomeStatus)) {
+    return true;
+  }
+  if (input.success === false && input.deliverySucceeded !== true) {
+    return true;
+  }
+  if (input.gateFailureDetails && input.winnerFallback !== true) {
+    return true;
+  }
+  return false;
+}
+function synthesisProducedUsableOutput(input, outcomeStatus, gateSummary) {
+  if (outcomeStatus === "applied" || input.synthesisApplied === true) {
+    return gateSummary === "passed" || input.gatesPassed === true;
+  }
+  return false;
+}
+function isWinnerRepair(input, outcomeStatus, acceptedDonorHunks, noveltyScore, gateSummary) {
+  if (acceptedDonorHunks > 0) return false;
+  if (input.winnerClone === true) return false;
+  if (noveltyScore !== null && noveltyScore <= NOVELTY_CARRY_FORWARD_THRESHOLD) {
+    return false;
+  }
+  if (!synthesisProducedUsableOutput(input, outcomeStatus, gateSummary)) {
+    return false;
+  }
+  return true;
+}
+function isDonorRejection(donorHunksConsidered, donorHunksRejected, acceptedDonorHunks, input) {
+  if (acceptedDonorHunks > 0) return false;
+  const diagnostic = input.donorMaterialDiagnostic;
+  const donorsConsidered = (donorHunksConsidered ?? 0) > 0 || (donorHunksRejected ?? 0) > 0 || (diagnostic?.consideredHunkCount ?? 0) > 0 || (diagnostic?.rejectedHunkCount ?? 0) > 0 || (diagnostic?.donorCount ?? 0) > 0;
+  if (!donorsConsidered) return false;
+  return input.winnerFallback === true || input.synthesisApplied !== true;
+}
+function hasNonBaseContributingVariants(baseVariant, contributingVariants) {
+  if (contributingVariants.length === 0) return false;
+  if (!baseVariant) {
+    return contributingVariants.length > 1;
+  }
+  const normalizedBase = normalizeVariantId(baseVariant);
+  return contributingVariants.some((variant) => normalizeVariantId(variant) !== normalizedBase);
+}
+function resolveBaseVariant(input) {
+  const fromManifest = input.harvestManifest?.baseWinner?.variantId;
+  if (typeof fromManifest === "string" && fromManifest.trim().length > 0) {
+    return normalizeVariantId(fromManifest);
+  }
+  const winnerFromDecisions = input.donorSelectionDecisions?.map((decision) => {
+    if (decision.winner !== true || typeof decision.variant !== "string") return null;
+    return normalizeVariantId(decision.variant);
+  }).find((value) => Boolean(value));
+  if (winnerFromDecisions) return winnerFromDecisions;
+  const declaredProvider = input.declaredWinner?.provider?.trim();
+  const declaredVariant = input.declaredWinner?.variant?.trim();
+  if (declaredProvider && declaredVariant) {
+    const variantId = declaredVariant.includes(":") ? declaredVariant : `${declaredProvider}:${declaredVariant}`;
+    return normalizeVariantId(variantId);
+  }
+  const merged = input.mergedVariants?.[0];
+  if (typeof merged === "string" && merged.trim().length > 0) {
+    return normalizeVariantId(merged);
+  }
+  return null;
+}
+function resolveSynthesisGateFlag(input) {
+  if (input.gatesPassed === true) return "passed";
+  if (input.gateFailureDetails || input.synthesisOutcomeStatus === "gate_failed") {
+    return "failed";
+  }
+  if (input.winnerFallback === true || input.synthesisOutcomeStatus === "winner_carry_forward") {
+    return "carried_forward";
+  }
+  if (input.gatesPassed === false) return "failed";
+  return null;
+}
+function synthesisGatesAllNotRun(snapshot) {
+  return gateSnapshotStatuses(snapshot).every((status) => status === "not_run");
+}
+function gateSnapshotStatuses(snapshot) {
+  return [
+    snapshot.buildStatus,
+    snapshot.lintStatus,
+    snapshot.testStatus,
+    snapshot.formatPassed ? "passed" : snapshot.formatStatus === "verified" ? "failed" : "not_run"
+  ];
+}
+function resolveGateSummary(input) {
+  const flag = resolveSynthesisGateFlag(input);
+  const snapshot = input.synthesisGateResults;
+  if (flag === "passed" && snapshot && synthesisGatesAllNotRun(snapshot)) return "not_run";
+  if (flag) return flag;
+  if (!snapshot) return "not_run";
+  const statuses = gateSnapshotStatuses(snapshot);
+  if (statuses.some((status) => status === "failed")) return "failed";
+  if (statuses.every((status) => status === "not_run")) return "not_run";
+  if (snapshot.isEligible) return "passed";
+  return "not_run";
+}
+function resolveFailureKind(outcomeStatus) {
+  if (!outcomeStatus || !SYNTHESIS_FAILED_STATUSES.has(outcomeStatus)) {
+    return "generation_failed";
+  }
+  return outcomeStatus;
+}
+function readHarvestCount(input, field) {
+  const fromManifest = input.harvestManifest?.summary?.[field];
+  if (typeof fromManifest === "number" && Number.isFinite(fromManifest)) {
+    return fromManifest;
+  }
+  const diagnosticField = field === "acceptedHunkCount" ? "acceptedHunkCount" : field === "rejectedHunkCount" ? "rejectedHunkCount" : "consideredHunkCount";
+  const fromDiagnostic = input.donorMaterialDiagnostic?.[diagnosticField];
+  if (typeof fromDiagnostic === "number" && Number.isFinite(fromDiagnostic)) {
+    return fromDiagnostic;
+  }
+  return null;
+}
+function normalizeOutcomeStatus(value) {
+  if (typeof value !== "string") return void 0;
+  return value;
+}
+function normalizeVariantList(values) {
+  if (!Array.isArray(values)) return [];
+  return values.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => normalizeVariantId(value));
+}
+function normalizeVariantId(variantId) {
+  return repairDuplicatedProviderSegment(variantId);
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((entry) => typeof entry === "string");
+  return strings.length > 0 ? strings : void 0;
+}
+function readDonorSelectionDecisions(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.map((entry) => {
+    if (typeof entry !== "object" || entry === null) return null;
+    const record = entry;
+    return {
+      variant: typeof record.variant === "string" ? record.variant : void 0,
+      winner: record.winner === true,
+      selected: record.selected === true
+    };
+  }).filter((entry) => entry !== null);
+}
+function isHarvestManifest(value) {
+  if (!value || typeof value !== "object") return false;
+  const manifest = value;
+  if (!manifest.summary || typeof manifest.summary !== "object") return false;
+  const summary = manifest.summary;
+  return typeof summary.acceptedHunkCount === "number" && typeof summary.rejectedHunkCount === "number" && typeof summary.consideredHunkCount === "number";
+}
+function isDonorMaterialDiagnostic(value) {
+  if (!value || typeof value !== "object") return false;
+  const diagnostic = value;
+  return typeof diagnostic.category === "string" && typeof diagnostic.reason === "string";
+}
+function isGateFailureDetails(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.gate === "string"
+  );
+}
+function isSynthesisGateResultSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value;
+  return typeof candidate.isEligible === "boolean" && typeof candidate.buildStatus === "string" && typeof candidate.lintStatus === "string" && typeof candidate.testStatus === "string";
+}
+
+export {
+  formatSynthesisValueRunSummaryLine,
+  deriveSynthesisValueFromMergedResult,
+  deriveSynthesisValueFromArtifactOrSummary,
+  resolveSynthesisGateFlag,
+  synthesisGatesAllNotRun
+};
+//# sourceMappingURL=chunk-I6FN3R5D.js.map