@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-PV53ODOT.js

@@ -0,0 +1,555 @@
+import {
+  buildDependencyIdentifierMap,
+  detectCycleFromAdjacency,
+  loadAllItems,
+  resolveDependencyId
+} from "./chunk-NXH3RX7O.js";
+import {
+  normalizeRef
+} from "./chunk-P5P2EKGH.js";
+import {
+  getBucketArchivePath,
+  getBucketPath,
+  getBuckets
+} from "./chunk-V3KLVK7B.js";
+import {
+  RAW_RELATIONSHIPS,
+  isNeutralRelationship,
+  isPersistedWorkEdge,
+  isRawRelationship
+} from "./chunk-352PCJLK.js";
+
+// src/planning/work-edge.ts
+function isLegalEdgeKind(type, fromKind, toKind) {
+  const isWorkItem = (kind) => kind === "backlog" || kind === "task";
+  if (!isWorkItem(fromKind) || !isWorkItem(toKind)) {
+    return false;
+  }
+  if (type === "supersedes") {
+    return fromKind === "backlog" && toKind === "backlog";
+  }
+  return true;
+}
+function canonicalize(rawRelationship, declaringId, targetId) {
+  switch (rawRelationship) {
+    case "blocks":
+      return { type: "depends_on", from: targetId, to: declaringId };
+    case "blocked-by":
+      return { type: "depends_on", from: declaringId, to: targetId };
+    case "supersedes":
+      return { type: "supersedes", from: declaringId, to: targetId };
+    case "superseded_by":
+      return { type: "supersedes", from: targetId, to: declaringId };
+  }
+}
+function buildDependsOnAdjacency(edges) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const ensure = (id) => {
+    let entry = adjacency.get(id);
+    if (!entry) {
+      entry = { prerequisites: [], unresolved: [], selfReference: false };
+      adjacency.set(id, entry);
+    }
+    return entry;
+  };
+  for (const edge of edges) {
+    if (edge.type !== "depends_on") {
+      continue;
+    }
+    const node = ensure(edge.from);
+    ensure(edge.to);
+    if (edge.from === edge.to) {
+      node.selfReference = true;
+      continue;
+    }
+    node.prerequisites.push(edge.to);
+  }
+  return adjacency;
+}
+function bindWorkEdge(context, declaringId, rawRelationship, rawTarget) {
+  if (!isRawRelationship(rawRelationship)) {
+    return {
+      ok: false,
+      code: "unknown_relationship",
+      message: `Unknown relationship '${rawRelationship}'. Expected one of: ${RAW_RELATIONSHIPS.join(", ")}.`
+    };
+  }
+  const declaringItem = context.itemsById.get(declaringId);
+  if (!declaringItem) {
+    return {
+      ok: false,
+      code: "unresolved_target",
+      message: `Declaring item not found: ${declaringId}.`
+    };
+  }
+  const normalizedTarget = normalizeRef(rawTarget);
+  if (context.index.collisions.has(normalizedTarget)) {
+    return {
+      ok: false,
+      code: "ambiguous_target",
+      message: `Ambiguous target '${rawTarget}': the identifier collides across multiple work items. Make ids/refs/aliases unique before binding.`
+    };
+  }
+  const targetId = resolveDependencyId(rawTarget, context.index);
+  if (!targetId) {
+    return {
+      ok: false,
+      code: "unresolved_target",
+      message: `Relationship target not found: ${rawTarget}.`
+    };
+  }
+  const targetItem = context.itemsById.get(targetId);
+  if (!targetItem) {
+    return {
+      ok: false,
+      code: "unresolved_target",
+      message: `Relationship target resolved to '${targetId}' but no work item exists for it.`
+    };
+  }
+  if (targetId === declaringId) {
+    return {
+      ok: false,
+      code: "self_edge",
+      message: `Self relationship rejected: ${declaringId} cannot relate to itself.`
+    };
+  }
+  const { type, from, to } = canonicalize(rawRelationship, declaringId, targetId);
+  const fromKind = context.itemsById.get(from)?.frontMatter.kind;
+  const toKind = context.itemsById.get(to)?.frontMatter.kind;
+  if (!fromKind || !toKind) {
+    return {
+      ok: false,
+      code: "unresolved_target",
+      message: `Could not resolve kinds for canonical edge ${from} -> ${to}.`
+    };
+  }
+  if (!isLegalEdgeKind(type, fromKind, toKind)) {
+    return {
+      ok: false,
+      code: "illegal_kind",
+      message: `Illegal ${type} edge ${from} (${fromKind}) -> ${to} (${toKind}). ${type === "supersedes" ? "Only a backlog item can supersede another backlog item." : "depends_on endpoints must each be a backlog item or a task."}`
+    };
+  }
+  const edge = {
+    from,
+    to,
+    type,
+    fromKind,
+    toKind,
+    status: "resolved",
+    declaredOn: declaringId,
+    declaredBy: rawRelationship
+  };
+  if (type === "depends_on") {
+    const adjacency = buildDependsOnAdjacency([...context.existingEdges, edge]);
+    const cycle = detectCycleFromAdjacency(from, (nodeId) => adjacency.get(nodeId));
+    if (!cycle.valid) {
+      const detail = cycle.errors[0]?.message ?? "cycle detected";
+      return {
+        ok: false,
+        code: "cycle",
+        message: `Relationship rejected: it would create a dependency cycle (${detail}).`
+      };
+    }
+  }
+  return { ok: true, edge };
+}
+function validateNeutralRelation(context, declaringId, rawTarget) {
+  if (!context.itemsById.get(declaringId)) {
+    return {
+      ok: false,
+      code: "unresolved_target",
+      message: `Declaring item not found: ${declaringId}.`
+    };
+  }
+  const normalizedTarget = normalizeRef(rawTarget);
+  if (context.index.collisions.has(normalizedTarget)) {
+    return {
+      ok: false,
+      code: "ambiguous_target",
+      message: `Ambiguous target '${rawTarget}': the identifier collides across multiple work items. Make ids/refs/aliases unique before relating.`
+    };
+  }
+  const targetId = resolveDependencyId(rawTarget, context.index);
+  if (!targetId || !context.itemsById.get(targetId)) {
+    return {
+      ok: false,
+      code: "unresolved_target",
+      message: `Relationship target not found: ${rawTarget}.`
+    };
+  }
+  if (targetId === declaringId) {
+    return {
+      ok: false,
+      code: "self_edge",
+      message: `Self relationship rejected: ${declaringId} cannot relate to itself.`
+    };
+  }
+  return { ok: true, targetId };
+}
+function toPersistedEdge(edge, declaredTarget) {
+  return {
+    from: edge.from,
+    to: edge.to,
+    type: edge.type,
+    fromKind: edge.fromKind,
+    toKind: edge.toKind,
+    declaredOn: edge.declaredOn ?? edge.from,
+    declaredBy: edge.declaredBy ?? "blocked-by",
+    declaredTarget
+  };
+}
+function fromPersistedEdge(persisted) {
+  return {
+    from: persisted.from,
+    to: persisted.to,
+    type: persisted.type,
+    fromKind: persisted.fromKind,
+    toKind: persisted.toKind,
+    status: "resolved",
+    declaredOn: persisted.declaredOn,
+    declaredBy: isRawRelationship(persisted.declaredBy) ? persisted.declaredBy : void 0
+  };
+}
+function readPersistedEdges(item) {
+  const raw = item.frontMatter.workEdges;
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.filter(isPersistedWorkEdge);
+}
+function hasMatchingDeclaration(item, persisted) {
+  if (persisted.declaredOn !== item.id) {
+    return false;
+  }
+  const related = item.frontMatter.relatedTasks;
+  if (!Array.isArray(related)) {
+    return false;
+  }
+  for (const entry of related) {
+    const targetRef = typeof entry === "string" ? entry : entry.id;
+    const relationship = typeof entry === "string" ? void 0 : entry.relationship;
+    if (targetRef === persisted.declaredTarget && relationship === persisted.declaredBy) {
+      return true;
+    }
+  }
+  return false;
+}
+function readAuthoritativeEdges(item) {
+  return readPersistedEdges(item).filter((edge) => hasMatchingDeclaration(item, edge));
+}
+function collectPersistedEdges(context) {
+  const edges = [];
+  for (const item of context.itemsById.values()) {
+    for (const persisted of readAuthoritativeEdges(item)) {
+      edges.push(fromPersistedEdge(persisted));
+    }
+  }
+  return edges;
+}
+var PLANNING_BUCKET_NAMES = ["backlog", "tech-debt", "parking-lot", "sprint", "task"];
+var FALLBACK_PLANNING_DIRECTORIES = [
+  "backlog",
+  "backlog/archive",
+  "tech-debt",
+  "tech-debt/archive",
+  "parking-lot",
+  "parking-lot/archive",
+  "sprint",
+  "sprint/archive",
+  "task",
+  "task/archive"
+];
+function resolvePlanningDirectories(rootDir) {
+  const buckets = getBuckets(rootDir);
+  const byName = new Map(buckets.map((b) => [b.name, b]));
+  const dirs = [];
+  for (const name of PLANNING_BUCKET_NAMES) {
+    const bucket = byName.get(name);
+    if (!bucket) continue;
+    dirs.push(getBucketPath(bucket, rootDir));
+    dirs.push(getBucketArchivePath(bucket, rootDir));
+  }
+  return dirs.length > 0 ? dirs : FALLBACK_PLANNING_DIRECTORIES;
+}
+async function loadWorkGraphContext(rootDir) {
+  const items = await loadAllItems(rootDir, resolvePlanningDirectories(rootDir));
+  const itemsById = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    itemsById.set(item.id, item);
+  }
+  const index = buildDependencyIdentifierMap(items);
+  return { itemsById, index, existingEdges: [] };
+}
+function forEachDeclaredRelation(context, visit) {
+  const ownerIds = [...context.itemsById.keys()].sort();
+  for (const ownerId of ownerIds) {
+    const item = context.itemsById.get(ownerId);
+    if (!item || item.frontMatter.kind !== "backlog") {
+      continue;
+    }
+    const related = item.frontMatter.relatedTasks;
+    if (!Array.isArray(related)) {
+      continue;
+    }
+    for (const entry of related) {
+      const targetRef = typeof entry === "string" ? entry : entry.id;
+      const relationship = typeof entry === "string" ? "" : entry.relationship ?? "";
+      if (!targetRef) {
+        continue;
+      }
+      visit(ownerId, targetRef, relationship);
+    }
+  }
+}
+function deriveAllBoundEdges(context) {
+  const accumulated = [];
+  forEachDeclaredRelation(context, (ownerId, targetRef, relationship) => {
+    if (!relationship || !isRawRelationship(relationship)) {
+      return;
+    }
+    const result = bindWorkEdge(
+      { ...context, existingEdges: accumulated },
+      ownerId,
+      relationship,
+      targetRef
+    );
+    if (result.ok) {
+      accumulated.push(result.edge);
+    }
+  });
+  return accumulated;
+}
+function findPersistedEdgeForDeclaration(persistedByOwner, ownerId, targetRef, relationship) {
+  const owned = persistedByOwner.get(ownerId);
+  if (!owned) {
+    return void 0;
+  }
+  return owned.find(
+    (edge) => edge.declaredBy === relationship && edge.declaredTarget === targetRef
+  );
+}
+function indexPersistedByOwner(context) {
+  const byOwner = /* @__PURE__ */ new Map();
+  for (const item of context.itemsById.values()) {
+    const persisted = readAuthoritativeEdges(item);
+    if (persisted.length === 0) {
+      continue;
+    }
+    byOwner.set(item.id, [...byOwner.get(item.id) ?? [], ...persisted]);
+  }
+  return byOwner;
+}
+function classifyDeclaredRelation(persistedByOwner, ownerId, targetRef, relationship) {
+  const persisted = findPersistedEdgeForDeclaration(
+    persistedByOwner,
+    ownerId,
+    targetRef,
+    relationship
+  );
+  if (persisted) {
+    return {
+      declaredOn: ownerId,
+      targetRef,
+      relationship,
+      canonical: fromPersistedEdge(persisted),
+      enforcement: "declared-validated"
+    };
+  }
+  if (isNeutralRelationship(relationship)) {
+    return {
+      declaredOn: ownerId,
+      targetRef,
+      relationship,
+      canonical: null,
+      enforcement: "declared-not-enforced",
+      reason: "neutral",
+      detail: 'Neutral "related" link: intentionally not bound to a work edge.'
+    };
+  }
+  return {
+    declaredOn: ownerId,
+    targetRef,
+    relationship,
+    canonical: null,
+    enforcement: "declared-not-enforced",
+    reason: isRawRelationship(relationship) ? void 0 : "unknown_relationship",
+    detail: "Relation has no persisted canonical edge (legacy/unbound); inspect with `build plan backlog graph migrate` (read-only report)."
+  };
+}
+function buildGraphShowView(context, itemId) {
+  const resolvedId = resolveDependencyId(itemId, context.index) ?? itemId;
+  const item = context.itemsById.get(resolvedId);
+  if (!item) {
+    return null;
+  }
+  const persistedByOwner = indexPersistedByOwner(context);
+  const edges = [];
+  const related = item.frontMatter.relatedTasks;
+  if (Array.isArray(related)) {
+    for (const entry of related) {
+      const targetRef = typeof entry === "string" ? entry : entry.id;
+      const relationship = typeof entry === "string" ? "" : entry.relationship ?? "";
+      if (!targetRef) {
+        continue;
+      }
+      if (!relationship) {
+        edges.push({
+          declaredOn: resolvedId,
+          targetRef,
+          relationship: relationship || "(none)",
+          canonical: null,
+          enforcement: "declared-not-enforced",
+          reason: "unknown_relationship",
+          detail: "Related entry has no relationship type; treated as declared-not-enforced."
+        });
+        continue;
+      }
+      edges.push(classifyDeclaredRelation(persistedByOwner, resolvedId, targetRef, relationship));
+    }
+  }
+  return {
+    id: resolvedId,
+    kind: item.frontMatter.kind,
+    title: item.frontMatter.title,
+    edges
+  };
+}
+function buildGraphBlockersView(context, itemId) {
+  const resolvedId = resolveDependencyId(itemId, context.index) ?? itemId;
+  const item = context.itemsById.get(resolvedId);
+  if (!item) {
+    return null;
+  }
+  const blockers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ownerIds = [...context.itemsById.keys()].sort();
+  for (const ownerId of ownerIds) {
+    const owner = context.itemsById.get(ownerId);
+    if (!owner) {
+      continue;
+    }
+    for (const persisted of readAuthoritativeEdges(owner)) {
+      if (persisted.type !== "depends_on") {
+        continue;
+      }
+      if (persisted.from !== resolvedId) {
+        continue;
+      }
+      if (seen.has(persisted.to)) {
+        continue;
+      }
+      seen.add(persisted.to);
+      const blockerItem = context.itemsById.get(persisted.to);
+      blockers.push({
+        id: persisted.to,
+        kind: persisted.toKind,
+        title: blockerItem?.frontMatter.title ?? "",
+        declaredOn: persisted.declaredOn
+      });
+    }
+  }
+  return { id: resolvedId, blockers };
+}
+function bindFailureToOutcome(code) {
+  switch (code) {
+    case "unresolved_target":
+      return "unresolved";
+    case "ambiguous_target":
+      return "ambiguous";
+    case "illegal_kind":
+      return "illegal";
+    case "cycle":
+      return "cyclic";
+    case "unknown_relationship":
+    case "self_edge":
+      return "legacy";
+  }
+}
+function buildMigrateReport(context) {
+  const edges = [];
+  const counts = {
+    bound: 0,
+    unresolved: 0,
+    ambiguous: 0,
+    illegal: 0,
+    cyclic: 0,
+    legacy: 0,
+    neutral: 0
+  };
+  const accumulated = collectPersistedEdges(context);
+  forEachDeclaredRelation(context, (ownerId, targetRef, relationship) => {
+    if (!relationship) {
+      edges.push({
+        ownerId,
+        targetRef,
+        relationship: "(none)",
+        outcome: "legacy",
+        detail: "Related entry has no relationship type."
+      });
+      counts.legacy++;
+      return;
+    }
+    if (isNeutralRelationship(relationship)) {
+      const neutralCheck = validateNeutralRelation(context, ownerId, targetRef);
+      if (!neutralCheck.ok) {
+        const outcome = bindFailureToOutcome(neutralCheck.code);
+        edges.push({ ownerId, targetRef, relationship, outcome, detail: neutralCheck.message });
+        counts[outcome]++;
+        return;
+      }
+      edges.push({
+        ownerId,
+        targetRef,
+        relationship,
+        outcome: "neutral",
+        detail: 'Neutral "related" link: intentionally not bound to a work edge.'
+      });
+      counts.neutral++;
+      return;
+    }
+    const result = bindWorkEdge(
+      { ...context, existingEdges: accumulated },
+      ownerId,
+      relationship,
+      targetRef
+    );
+    if (result.ok) {
+      accumulated.push(result.edge);
+      edges.push({
+        ownerId,
+        targetRef,
+        relationship,
+        outcome: "bound",
+        canonical: result.edge
+      });
+      counts.bound++;
+    } else {
+      const outcome = bindFailureToOutcome(result.code);
+      edges.push({
+        ownerId,
+        targetRef,
+        relationship,
+        outcome,
+        detail: result.message
+      });
+      counts[outcome]++;
+    }
+  });
+  return { edges, counts };
+}
+
+export {
+  bindWorkEdge,
+  validateNeutralRelation,
+  toPersistedEdge,
+  readPersistedEdges,
+  readAuthoritativeEdges,
+  collectPersistedEdges,
+  loadWorkGraphContext,
+  deriveAllBoundEdges,
+  buildGraphShowView,
+  buildGraphBlockersView,
+  buildMigrateReport
+};
+//# sourceMappingURL=chunk-PV53ODOT.js.map

package/dist/chunk-PVJBTI7P.js

@@ -0,0 +1,24 @@
+// src/core/providers/artifact-paths.ts
+import * as fs from "fs";
+import * as path from "path";
+var PROVIDER_ARTIFACTS_SUBDIR = path.join(".build-project", "providers");
+var LEGACY_PROVIDER_ARTIFACTS_DIR = "providers";
+function resolveArtifactFile(cwd, filename) {
+  const canonical = path.join(cwd, PROVIDER_ARTIFACTS_SUBDIR, filename);
+  if (fs.existsSync(canonical)) {
+    return canonical;
+  }
+  const legacy = path.join(cwd, LEGACY_PROVIDER_ARTIFACTS_DIR, filename);
+  if (fs.existsSync(legacy)) {
+    return legacy;
+  }
+  return canonical;
+}
+function resolveProviderPricingPath(cwd = process.cwd()) {
+  return resolveArtifactFile(cwd, "pricing.json");
+}
+
+export {
+  resolveProviderPricingPath
+};
+//# sourceMappingURL=chunk-PVJBTI7P.js.map

package/dist/chunk-PXKERBKX.js

@@ -0,0 +1,100 @@
+import {
+  UNPARSEABLE_BUILD_SENTINEL,
+  UNPARSEABLE_LINT_SENTINEL,
+  UNPARSEABLE_TEST_SENTINEL,
+  countUnparseableDiagnostics,
+  extractBiomeLintIssues,
+  extractTestFailures,
+  extractTypeScriptIssues,
+  parseBuildFailure,
+  parseLintFailure,
+  parseTestFailure
+} from "./chunk-TUQMMFEQ.js";
+import {
+  describeVerificationCommand
+} from "./chunk-EPAMVGI3.js";
+
+// src/core/project/parse-verification-errors.ts
+function channelForKind(kind) {
+  if (kind === "test") return "test";
+  if (kind === "lint" || kind === "format") return "lint";
+  return "build";
+}
+function parseVerificationErrors(descriptor, output, failed, failingTests = []) {
+  const channel = channelForKind(descriptor.kind);
+  const isNode = descriptor.language === "node";
+  if (channel === "test") {
+    const structured2 = extractTestFailures(failingTests, output);
+    if (structured2.size > 0) {
+      return { channel, issues: structured2, parsed: true };
+    }
+    if (failed) {
+      structured2.add(
+        parseTestFailure(UNPARSEABLE_TEST_SENTINEL, void 0, countUnparseableDiagnostics(output))
+      );
+      return { channel, issues: structured2, parsed: false };
+    }
+    return { channel, issues: structured2, parsed: true };
+  }
+  if (channel === "lint") {
+    const structured2 = isNode ? extractBiomeLintIssues(output) : extractBiomeLintIssues("");
+    if (structured2.size > 0) {
+      return { channel, issues: structured2, parsed: true };
+    }
+    if (failed) {
+      structured2.add(
+        parseLintFailure(UNPARSEABLE_LINT_SENTINEL, void 0, countUnparseableDiagnostics(output))
+      );
+      return { channel, issues: structured2, parsed: false };
+    }
+    return { channel, issues: structured2, parsed: true };
+  }
+  const structured = isNode ? extractTypeScriptIssues(output) : extractTypeScriptIssues("");
+  if (structured.size > 0) {
+    return { channel, issues: structured, parsed: true };
+  }
+  if (failed) {
+    structured.add(
+      parseBuildFailure(UNPARSEABLE_BUILD_SENTINEL, void 0, countUnparseableDiagnostics(output))
+    );
+    return { channel, issues: structured, parsed: false };
+  }
+  return { channel, issues: structured, parsed: true };
+}
+function parseVerificationErrorsForCommand(command, output, failed, failingTests = []) {
+  return parseVerificationErrors(
+    describeVerificationCommand(command),
+    output,
+    failed,
+    failingTests
+  );
+}
+var CHANNEL_KIND = {
+  build: "build",
+  lint: "lint",
+  test: "test"
+};
+function parseVerificationErrorsForChannel(channel, language, output, failed, failingTests = []) {
+  const descriptor = {
+    command: "",
+    language,
+    kind: CHANNEL_KIND[channel],
+    scope: "unknown",
+    costClass: "unknown"
+  };
+  return parseVerificationErrors(descriptor, output, failed, failingTests);
+}
+
+// src/core/project/verification-unavailable.ts
+var LEGACY_UNAVAILABLE_FINDING_TEXT = /\b(?:verification(?: tool)? unavailable|no .+ command is available)\b/i;
+function isUnavailableVerificationFinding(finding) {
+  if (finding.unavailableReason !== void 0) return true;
+  return finding.severity === "warning" && LEGACY_UNAVAILABLE_FINDING_TEXT.test(finding.outputTail ?? "");
+}
+
+export {
+  parseVerificationErrorsForCommand,
+  parseVerificationErrorsForChannel,
+  isUnavailableVerificationFinding
+};
+//# sourceMappingURL=chunk-PXKERBKX.js.map

package/dist/chunk-PZ5AY32C.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-PZ5AY32C.js.map