@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-LDWNBEN7.js

@@ -0,0 +1,541 @@
+import {
+  isDeferSyncEnabled
+} from "./chunk-TRURQUBP.js";
+import {
+  createCliTable
+} from "./chunk-JNSTWNNW.js";
+import {
+  queryCanonicalPlanningProjection
+} from "./chunk-PFLDWMX6.js";
+import {
+  withReadableSharedBuckets
+} from "./chunk-FYTAA5FG.js";
+import {
+  formatSprintNotFoundMessage
+} from "./chunk-EP4SVAVI.js";
+import {
+  emitPlanningStateWarning
+} from "./chunk-RQFX6YRN.js";
+import {
+  calculateCapacity,
+  computeSprintTerminalReadiness,
+  getCurrentSprint,
+  listSprints,
+  listTasksInSprint
+} from "./chunk-L2CBG5IX.js";
+import {
+  getAllTasks
+} from "./chunk-7LHJDJB3.js";
+import {
+  loadBacklogExecutionProvenance,
+  projectAdvisoryExecutionEvidence
+} from "./chunk-3WY5TU2O.js";
+import {
+  loadSprintCompletedTaskIds
+} from "./chunk-R5EXHMUN.js";
+import {
+  classifyTaskDependency
+} from "./chunk-NXH3RX7O.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  getPlanningRoot
+} from "./chunk-CSXLLEGB.js";
+import {
+  legacyAssigneeValue,
+  projectWorkOwnership
+} from "./chunk-6G57FYBV.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind,
+  listEnabledBuckets
+} from "./chunk-V3KLVK7B.js";
+import {
+  createSafeErrorMessage
+} from "./chunk-I7SCBHJN.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  loadStorageConfig
+} from "./chunk-7VRJHTGZ.js";
+
+// src/cli/commands/plan-sprint-status-fast.ts
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/planning/team-visibility-read-model.ts
+import * as path from "path";
+function unavailable(reason) {
+  return { status: "unavailable", reason };
+}
+function available(value) {
+  return { status: "available", value };
+}
+function projectUpdateAge(updatedAt, nowMs) {
+  const updatedAtMs = Date.parse(updatedAt);
+  if (!Number.isFinite(updatedAtMs)) {
+    return unavailable("Task update timestamp is invalid");
+  }
+  if (updatedAtMs > nowMs) {
+    return unavailable("Task update timestamp is in the future");
+  }
+  return available(nowMs - updatedAtMs);
+}
+function projectTeamWorkBlockers(task, tasksById, provenanceBlockers, completedTaskIds) {
+  const blockers = [];
+  if (task.status === "blocked") {
+    blockers.push({
+      kind: "task-status",
+      id: task.id,
+      reason: task.blockedReason ?? null
+    });
+  }
+  for (const dependencyId of task.dependencies) {
+    const dependency = tasksById.get(dependencyId);
+    const classification = classifyTaskDependency(dependencyId, {
+      task: dependency ? { status: dependency.status } : null,
+      recordedComplete: completedTaskIds?.has(dependencyId)
+    });
+    if (!classification.satisfied) {
+      blockers.push({
+        kind: "dependency",
+        id: dependencyId,
+        reason: classification.state === "missing" ? "Dependency is missing" : `Dependency status is ${classification.status}`
+      });
+    }
+  }
+  for (const pending of provenanceBlockers) {
+    blockers.push({
+      kind: "provenance",
+      id: pending.id ?? task.id,
+      reason: pending.question
+    });
+  }
+  return blockers;
+}
+function projectActiveTeamWork(tasks, options = {}) {
+  const nowMs = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  const branchesByTaskId = new Map(
+    (options.branches ?? []).filter((entry) => entry.branch.trim().length > 0).map((entry) => [entry.taskId, entry.branch.trim()])
+  );
+  const worktreesByTaskId = new Map(
+    (options.worktrees ?? []).filter((entry) => entry.worktree.trim().length > 0).map((entry) => [entry.taskId, entry.worktree.trim()])
+  );
+  const tasksById = new Map(tasks.map((task) => [task.id, task]));
+  return tasks.filter((task) => task.status === "in_progress").map((task) => {
+    const ownership = projectWorkOwnership(task.ownership, task.assignee);
+    const assignee = legacyAssigneeValue(ownership, task.assignee);
+    const backlogItemId = typeof task.backlogItemId === "string" && task.backlogItemId.trim().length > 0 ? task.backlogItemId.trim() : void 0;
+    const provenance = backlogItemId && options.provenanceByBacklogItemId ? options.provenanceByBacklogItemId.get(backlogItemId) ?? null : null;
+    const hasProvenanceLookup = Boolean(
+      backlogItemId && options.provenanceByBacklogItemId?.has(backlogItemId)
+    );
+    const evidence = projectAdvisoryExecutionEvidence(hasProvenanceLookup ? provenance : null);
+    const injectedBranch = branchesByTaskId.get(task.id);
+    const branch = injectedBranch ?? evidence.branch;
+    const worktree = worktreesByTaskId.get(task.id);
+    const completionError = task.dependencies.some((id) => !tasksById.has(id)) ? options.completionErrorsBySprint?.get(task.sprintId) : void 0;
+    return {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      assignee: assignee ? available(assignee) : unavailable("Task has no assignee"),
+      ownership: ownership ? available(ownership) : unavailable("Task has no owner"),
+      blockers: completionError ? unavailable(completionError) : available(
+        projectTeamWorkBlockers(
+          task,
+          tasksById,
+          evidence.pendingBlockers,
+          options.completedTaskIdsBySprint?.get(task.sprintId)
+        )
+      ),
+      run: evidence.run ? available(evidence.run) : unavailable(
+        backlogItemId ? "No backlog execution provenance is associated with this task" : "Task is not linked to a backlog item with execution provenance"
+      ),
+      branch: branch ? available(branch) : unavailable("No branch evidence is associated with this task"),
+      worktree: worktree ? available(worktree) : unavailable("No worktree evidence is recorded in provenance"),
+      commit: evidence.commit ? available(evidence.commit) : unavailable("No merge commit is recorded in provenance"),
+      pr: evidence.prNumber !== null ? available(evidence.prNumber) : unavailable("No pull request number is recorded in provenance"),
+      updatedAt: task.updated_at,
+      updateAgeMs: projectUpdateAge(task.updated_at, nowMs)
+    };
+  });
+}
+function planningPathspecs(repoRoot) {
+  return Array.from(
+    new Set(
+      listEnabledBuckets(repoRoot).flatMap((bucket) => [
+        getBucketPathByKind(bucket.name, repoRoot),
+        getBucketArchivePathByKind(bucket.name, repoRoot)
+      ]).map((bucketPath) => path.relative(repoRoot, bucketPath).replace(/\\/g, "/")).filter((bucketPath) => bucketPath.length > 0 && !bucketPath.startsWith("..")).sort()
+    )
+  );
+}
+async function queryUnpushedPlanningCommits(repoRoot, git) {
+  let pathspecs;
+  try {
+    if (loadStorageConfig(repoRoot).backend === "git-branch") {
+      return unavailable("Planning commits publish to the storage branch, not this checkout");
+    }
+    pathspecs = planningPathspecs(repoRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return unavailable(`Planning bucket paths are unavailable: ${message}`);
+  }
+  if (pathspecs.length === 0) {
+    return unavailable("No enabled planning bucket paths are configured");
+  }
+  try {
+    const upstream = await git(
+      ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+      { cwd: repoRoot }
+    );
+    const upstreamRef = upstream.stdout.trim();
+    if (upstream.exitCode !== 0 || upstreamRef.length === 0) {
+      return unavailable("Current branch has no available upstream tracking ref");
+    }
+    const countResult = await git(
+      ["rev-list", "--count", `${upstreamRef}..HEAD`, "--", ...pathspecs],
+      { cwd: repoRoot }
+    );
+    const countText = countResult.stdout.trim();
+    const count = Number.parseInt(countText, 10);
+    if (countResult.exitCode !== 0 || !/^\d+$/.test(countText) || !Number.isSafeInteger(count) || count < 0) {
+      return unavailable("Git could not determine the unpushed planning commit count");
+    }
+    return available(count);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return unavailable(`Git evidence is unavailable: ${message}`);
+  }
+}
+async function queryPlanningSyncHealth(options) {
+  const lastSyncFailure = options.lastSyncFailure;
+  const failureMessage = lastSyncFailure?.message.trim();
+  return {
+    advisory: true,
+    deferSyncActive: options.deferSyncEnabled ?? isDeferSyncEnabled(),
+    unpushedPlanningCommits: await queryUnpushedPlanningCommits(
+      options.repoRoot,
+      options.git ?? execGit
+    ),
+    lastSyncFailure: lastSyncFailure && failureMessage ? available({ ...lastSyncFailure, message: failureMessage }) : unavailable("Planning sync failures are not persisted by the current sync path")
+  };
+}
+async function resolveProvenanceByBacklogItemId(options) {
+  if (options.provenanceByBacklogItemId) {
+    return options.provenanceByBacklogItemId;
+  }
+  if (!options.loadProvenance) {
+    return void 0;
+  }
+  const ids = [
+    ...new Set(
+      options.tasks.map((task) => typeof task.backlogItemId === "string" ? task.backlogItemId.trim() : "").filter((id) => id.length > 0)
+    )
+  ];
+  const provenanceByBacklogItemId = /* @__PURE__ */ new Map();
+  await Promise.all(
+    ids.map(async (backlogItemId) => {
+      try {
+        provenanceByBacklogItemId.set(backlogItemId, await options.loadProvenance(backlogItemId));
+      } catch {
+        provenanceByBacklogItemId.set(backlogItemId, null);
+      }
+    })
+  );
+  return provenanceByBacklogItemId;
+}
+async function queryTeamVisibility(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const provenanceByBacklogItemId = await resolveProvenanceByBacklogItemId(options);
+  const completedTaskIdsBySprint = /* @__PURE__ */ new Map();
+  const completionErrorsBySprint = /* @__PURE__ */ new Map();
+  const knownTaskIds = new Set(options.tasks.map((task) => task.id));
+  await Promise.all(
+    [
+      ...new Set(
+        options.tasks.filter(
+          (task) => task.status === "in_progress" && task.dependencies.some((id) => !knownTaskIds.has(id))
+        ).map((task) => task.sprintId)
+      )
+    ].map(async (sprintId) => {
+      if (!sprintId) return;
+      try {
+        completedTaskIdsBySprint.set(
+          sprintId,
+          await loadSprintCompletedTaskIds(sprintId, options.repoRoot)
+        );
+      } catch (error) {
+        completionErrorsBySprint.set(
+          sprintId,
+          `Sprint completion evidence unavailable: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    })
+  );
+  const [work, syncHealth] = await Promise.all([
+    Promise.resolve(
+      projectActiveTeamWork(options.tasks, {
+        branches: options.branches,
+        worktrees: options.worktrees,
+        provenanceByBacklogItemId,
+        completedTaskIdsBySprint,
+        completionErrorsBySprint,
+        now
+      })
+    ),
+    queryPlanningSyncHealth(options)
+  ]);
+  return { observedAt: now.toISOString(), work, syncHealth };
+}
+
+// src/planning/planning-workspace-envelope.ts
+var PLANNING_WORKSPACE_ENVELOPE_VERSION = "1.0.0";
+function unavailable2(error) {
+  return { state: "unavailable", reason: error instanceof Error ? error.message : String(error) };
+}
+async function defaultTeamVisibility() {
+  const planningRoot = getPlanningRoot();
+  const tasks = await getAllTasks({ includeArchive: true });
+  return queryTeamVisibility({
+    repoRoot: planningRoot,
+    tasks: tasks.map((task) => task.yaml),
+    loadProvenance: (backlogItemId) => loadBacklogExecutionProvenance(planningRoot, backlogItemId)
+  });
+}
+async function buildPlanningWorkspaceEnvelopeV1(readers = {}) {
+  const [canonicalResult, visibilityResult] = await Promise.allSettled([
+    (readers.queryCanonical ?? queryCanonicalPlanningProjection)(),
+    (readers.queryTeamVisibility ?? defaultTeamVisibility)()
+  ]);
+  return {
+    schemaVersion: PLANNING_WORKSPACE_ENVELOPE_VERSION,
+    canonical: canonicalResult.status === "fulfilled" ? {
+      state: "available",
+      value: {
+        activeSprint: canonicalResult.value.activeSprint,
+        tasks: canonicalResult.value.tasks,
+        // Preserve Build order and whyIncluded; BB must not re-rank.
+        nextCandidates: canonicalResult.value.nextCandidates
+      }
+    } : unavailable2(canonicalResult.reason),
+    teamVisibility: visibilityResult.status === "fulfilled" ? { state: "available", value: visibilityResult.value } : unavailable2(visibilityResult.reason)
+  };
+}
+
+// src/planning/sprint-status-read-model.ts
+async function querySprintStatus(sprintId) {
+  let targetSprintId = sprintId;
+  if (!targetSprintId) {
+    const current = await getCurrentSprint();
+    if (!current) return null;
+    targetSprintId = current.yaml.id;
+  }
+  const [capacity, allTasks, activeSprints, archivedSprints, repositoryTasks] = await Promise.all([
+    calculateCapacity(targetSprintId),
+    listTasksInSprint(targetSprintId),
+    listSprints(false),
+    listSprints(true),
+    getAllTasks({ includeArchive: true })
+  ]);
+  const activeSprint = activeSprints.find((s) => s.id === targetSprintId);
+  const archivedSprint = archivedSprints.find((s) => s.id === targetSprintId);
+  const sprint = activeSprint ?? archivedSprint;
+  const archived = !activeSprint && Boolean(archivedSprint);
+  const missingTaskIds = allTasks.filter((t) => t.missing === true).map((t) => t.id);
+  const tasks = allTasks.filter((t) => t.missing !== true);
+  const tasksByStatus = {
+    todo: tasks.filter((t) => t.status === "todo"),
+    in_progress: tasks.filter((t) => t.status === "in_progress"),
+    review: tasks.filter((t) => t.status === "review"),
+    done: tasks.filter((t) => t.status === "done"),
+    blocked: tasks.filter((t) => t.status === "blocked"),
+    cancelled: tasks.filter((t) => t.status === "cancelled")
+  };
+  const activeDoneHours = tasksByStatus.done.reduce((sum, task) => sum + task.estimatedHours, 0);
+  const archivedDoneTasks = repositoryTasks.filter((result) => result.isArchived).map((result) => result.yaml).filter((task) => task.status === "done" && task.originalSprintId === targetSprintId);
+  const archivedDoneHours = archivedDoneTasks.reduce((sum, task) => sum + task.estimatedHours, 0);
+  const allDone = tasks.length > 0 && tasksByStatus.done.length === tasks.length;
+  const allTerminal = tasks.length > 0 && tasksByStatus.done.length + tasksByStatus.blocked.length + tasksByStatus.cancelled.length === tasks.length;
+  const readiness = computeSprintTerminalReadiness(allTasks);
+  const integrityClean = readiness.missingTaskIds.length === 0;
+  const closable = sprint?.status === "active" && readiness.ready;
+  return {
+    sprintId: targetSprintId,
+    name: sprint?.name ?? targetSprintId,
+    status: sprint?.status ?? "unknown",
+    archived,
+    startDate: sprint?.startDate,
+    endDate: sprint?.endDate,
+    goal: sprint?.goal,
+    capacity: {
+      allocatedHours: capacity.allocatedHours,
+      totalHours: capacity.totalHours,
+      utilizationPercent: capacity.utilizationPercent
+    },
+    completedCapacity: {
+      activeDoneHours,
+      archivedDoneHours,
+      totalDoneHours: activeDoneHours + archivedDoneHours,
+      archivedTaskCount: archivedDoneTasks.length
+    },
+    progress: {
+      todo: tasksByStatus.todo.length,
+      in_progress: tasksByStatus.in_progress.length,
+      review: tasksByStatus.review.length,
+      done: tasksByStatus.done.length,
+      blocked: tasksByStatus.blocked.length,
+      cancelled: tasksByStatus.cancelled.length,
+      total: tasks.length,
+      allDone,
+      allTerminal,
+      integrityClean,
+      closable
+    },
+    tasks: tasks.map((t) => ({
+      id: t.id,
+      title: t.title,
+      status: t.status,
+      estimatedHours: t.estimatedHours,
+      ...typeof t.expectedRuntimeMinutes === "number" && t.expectedRuntimeMinutes > 0 ? { expectedRuntimeMinutes: t.expectedRuntimeMinutes } : {},
+      resultArtifactPath: t.resultArtifactPath
+    })),
+    missingTaskIds
+  };
+}
+
+// src/cli/commands/plan-sprint-status-fast.ts
+function reportSprintStatusFailure(error, sprintId, json) {
+  if (error instanceof ExitCodeError) {
+    throw error;
+  }
+  const notFoundMessage = formatSprintNotFoundMessage(error, sprintId);
+  if (notFoundMessage) {
+    if (json) {
+      process.stdout.write(`${JSON.stringify({ error: notFoundMessage })}
+`);
+      throw new ExitCodeError(1);
+    }
+    console.error(chalk.red(notFoundMessage));
+    throw new ExitCodeError(1);
+  }
+  const message = createSafeErrorMessage(error, "sprint status");
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ error: message })}
+`);
+    throw new ExitCodeError(1);
+  }
+  console.error(chalk.red(`Error showing status: ${message}`));
+  throw new ExitCodeError(1);
+}
+async function runPlanSprintStatusAction(sprintId, options = {}) {
+  try {
+    await emitPlanningStateWarning(options.json === true);
+    const result = await querySprintStatus(sprintId);
+    if (options.json) {
+      const output = sprintId === void 0 ? {
+        ...result ?? {},
+        planningWorkspaceV1: await (options.buildPlanningWorkspaceEnvelope ?? buildPlanningWorkspaceEnvelopeV1)()
+      } : result;
+      process.stdout.write(`${JSON.stringify(output, null, 2)}
+`);
+      return;
+    }
+    if (!result) {
+      console.log("");
+      console.log(chalk.yellow("No active sprint found"));
+      console.log("");
+      console.log(chalk.dim("To view all sprints:"));
+      console.log(chalk.dim("  build plan sprint list"));
+      console.log("");
+      console.log(chalk.dim("To create a new sprint:"));
+      console.log(
+        chalk.dim(
+          '  build plan sprint create --name "Sprint 1" --start <start-date> --end <end-date>'
+        )
+      );
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk.bold(`Sprint Status: ${result.sprintId}`));
+    console.log("");
+    console.log(chalk.bold("Progress:"));
+    console.log(chalk.dim("  To Do:"), result.progress.todo);
+    console.log(chalk.blue("  In Progress:"), result.progress.in_progress);
+    console.log(chalk.yellow("  Review:"), result.progress.review);
+    console.log(
+      chalk.green("  Done (active):"),
+      `${result.progress.done} ${result.progress.done === 1 ? "task" : "tasks"}, ${result.completedCapacity.activeDoneHours}h`
+    );
+    console.log(
+      chalk.green("  Done (archived):"),
+      `${result.completedCapacity.archivedTaskCount} ${result.completedCapacity.archivedTaskCount === 1 ? "task" : "tasks"}, ${result.completedCapacity.archivedDoneHours}h`
+    );
+    const totalDoneTasks = result.progress.done + result.completedCapacity.archivedTaskCount;
+    console.log(
+      chalk.green("  Done (total):"),
+      `${totalDoneTasks} ${totalDoneTasks === 1 ? "task" : "tasks"}, ${result.completedCapacity.totalDoneHours}h`
+    );
+    console.log(chalk.red("  Blocked:"), result.progress.blocked);
+    console.log(chalk.dim("  Cancelled:"), result.progress.cancelled);
+    console.log("");
+    if (result.progress.closable) {
+      console.log(chalk.green("OK All sprint tasks are done"));
+      console.log(chalk.dim(`Next: build plan sprint close ${result.sprintId}`));
+      console.log("");
+    }
+    if (result.missingTaskIds.length > 0) {
+      console.log(
+        chalk.yellow(
+          `Warning: sprint references ${result.missingTaskIds.length} task ID(s) with no task file:`
+        )
+      );
+      for (const id of result.missingTaskIds) {
+        console.log(chalk.dim(`  - ${id}`));
+      }
+      if (result.status === "completed" || result.archived) {
+        console.log(
+          chalk.dim(
+            "Repair: prune-missing does not mutate completed or archived sprints; restore the sprint before pruning."
+          )
+        );
+      } else {
+        console.log(chalk.dim(`Repair: build plan sprint prune-missing ${result.sprintId}`));
+      }
+      console.log("");
+    }
+    if (result.tasks.length > 0) {
+      const table = createCliTable({
+        head: [chalk.cyan("ID"), chalk.cyan("Title"), chalk.cyan("Status")],
+        colWidths: [35, 45, 15],
+        fullValuesWhenPiped: true
+      });
+      for (const task of result.tasks) {
+        const statusColor = task.status === "done" ? chalk.green : task.status === "in_progress" ? chalk.blue : task.status === "review" ? chalk.yellow : chalk.dim;
+        table.push([task.id, task.title.slice(0, 42), statusColor(task.status)]);
+      }
+      console.log(table.toString());
+      console.log("");
+    }
+  } catch (error) {
+    reportSprintStatusFailure(error, sprintId, options.json);
+  }
+}
+function createPlanSprintStatusFastCommand() {
+  const plan = new Command("plan").alias("pl").description("Work definition and organization");
+  const sprint = new Command("sprint").description("Manage sprints");
+  sprint.command("status [sprint-id]").description("Show detailed sprint status").option("--json", "Output structured JSON instead of formatted text").action(withReadableSharedBuckets(["plan", "sprint", "status"], runPlanSprintStatusAction));
+  plan.addCommand(sprint);
+  return plan;
+}
+
+export {
+  querySprintStatus,
+  runPlanSprintStatusAction,
+  createPlanSprintStatusFastCommand
+};
+//# sourceMappingURL=chunk-LDWNBEN7.js.map