@ebrindley/build 0.0.0-stage → 2026.11.14-rc.1

package/dist/chunk-FOEINBBP.js

@@ -0,0 +1,268 @@
+import {
+  createCliTable
+} from "./chunk-JNSTWNNW.js";
+import {
+  withReadableSharedBuckets
+} from "./chunk-7E5NKFMT.js";
+import {
+  emitPlanningStateWarning
+} from "./chunk-OECHS63F.js";
+import {
+  getCurrentSprint,
+  listTasksInSprint
+} from "./chunk-NLK4HOEL.js";
+import {
+  getAllTasks
+} from "./chunk-6G3XRYS3.js";
+import {
+  TASK_STATUSES,
+  isTaskStatus
+} from "./chunk-NAINGKHF.js";
+import {
+  parseTaskBody
+} from "./chunk-IAAFU3XY.js";
+import {
+  ExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  readMarkdownFile
+} from "./chunk-352PCJLK.js";
+
+// src/cli/commands/task-list-fast.ts
+import chalk2 from "chalk";
+import { Command } from "commander";
+
+// src/planning/task-list-projection.ts
+var TASK_CATALOG_SCHEMA_VERSION = "1.0.0";
+async function projectTaskCatalog(tasks, readBody) {
+  const rows = await Promise.all(
+    tasks.map(async ({ yaml, filePath, isArchived }) => {
+      let objective = "";
+      try {
+        objective = parseTaskBody(await readBody(filePath)).description;
+      } catch {
+      }
+      return {
+        id: yaml.id,
+        title: yaml.title,
+        objective,
+        sprintId: yaml.sprintId || yaml.originalSprintId || "",
+        status: yaml.status,
+        priority: yaml.priority,
+        location: isArchived ? "archive" : "active",
+        createdAt: yaml.created_at,
+        updatedAt: yaml.updated_at
+      };
+    })
+  );
+  return {
+    schemaVersion: TASK_CATALOG_SCHEMA_VERSION,
+    scope: "all",
+    total: rows.length,
+    tasks: rows
+  };
+}
+async function getTaskCatalog() {
+  const tasks = await getAllTasks({ includeArchive: true });
+  return projectTaskCatalog(tasks, async (filePath) => (await readMarkdownFile(filePath)).body);
+}
+
+// src/cli/commands/task-list-presentation.ts
+import chalk from "chalk";
+function normalizeTaskListStatusInput(status) {
+  return status === "in-progress" ? "in_progress" : status;
+}
+function buildTaskListJsonOutput(sprintId, status, tasks, missingTaskIds) {
+  return {
+    sprintId,
+    status: status ?? null,
+    total: tasks.length,
+    missingTaskIds,
+    tasks: tasks.map((task) => ({
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      priority: task.priority ?? "P2",
+      estimatedHours: task.estimatedHours,
+      ...task.expectedRuntimeMinutes !== void 0 ? { expectedRuntimeMinutes: task.expectedRuntimeMinutes } : {},
+      resultArtifactPath: task.resultArtifactPath
+    }))
+  };
+}
+function formatNoActiveSprintText() {
+  return [
+    "",
+    chalk.yellow("No active sprint found"),
+    "",
+    chalk.dim("To view all sprints:"),
+    chalk.dim("  build plan sprint list"),
+    "",
+    chalk.dim("To create a new sprint:"),
+    chalk.dim('  build plan sprint create --name "Sprint 1" --start <start-date> --end <end-date>'),
+    ""
+  ];
+}
+function statusColor(status) {
+  if (status === "done") return chalk.green;
+  if (status === "in_progress") return chalk.blue;
+  if (status === "review") return chalk.yellow;
+  return chalk.dim;
+}
+function formatTaskListText(input) {
+  const { sprintId, status, tasks, missingTaskIds } = input;
+  if (tasks.length === 0 && missingTaskIds.length === 0) {
+    return [chalk.yellow("No tasks found")];
+  }
+  const lines = ["", chalk.bold(`Tasks in ${sprintId}`)];
+  if (status) lines.push(chalk.dim(`Filtered by status: ${status}`));
+  lines.push("");
+  if (tasks.length > 0) {
+    const table = createCliTable({
+      head: [chalk.cyan("Title"), chalk.cyan("ID"), chalk.cyan("Priority"), chalk.cyan("Status")],
+      colWidths: [35, 35, 10, 15],
+      fullValuesWhenPiped: true
+    });
+    for (const task of tasks) {
+      const color = statusColor(task.status);
+      table.push([task.title.slice(0, 32), task.id, task.priority ?? "P2", color(task.status)]);
+    }
+    lines.push(table.toString(), "", chalk.dim(`Total: ${tasks.length} tasks`));
+    const reasons = tasks.flatMap((task) => {
+      const reason = task.status === "blocked" ? task.blockedReason?.trim() || task.lastTransitionReason?.trim() : task.status === "review" ? task.lastTransitionReason?.trim() : void 0;
+      return reason ? [chalk.dim(`  ${task.id}: ${reason}`)] : [];
+    });
+    if (reasons.length > 0) {
+      lines.push("", chalk.cyan("Reasons:"), ...reasons);
+    }
+  } else {
+    lines.push(chalk.yellow("No resolvable task files found"));
+  }
+  if (missingTaskIds.length > 0) {
+    lines.push(
+      "",
+      chalk.yellow(
+        `Warning: sprint references ${missingTaskIds.length} task ID(s) with no task file:`
+      ),
+      ...missingTaskIds.map((id) => chalk.dim(`  - ${id}`)),
+      chalk.dim(`Repair: build plan sprint prune-missing ${sprintId}`)
+    );
+  }
+  lines.push("");
+  return lines;
+}
+
+// src/cli/commands/task-list-fast.ts
+function failJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+  throw new ExitCodeError(1);
+}
+function failText(message, hint) {
+  console.error(chalk2.red(message));
+  if (hint) {
+    console.error(chalk2.yellow(hint));
+  }
+  throw new ExitCodeError(1);
+}
+function printNoActiveSprintEmptyState(json, statusFilter) {
+  if (json) {
+    console.log(JSON.stringify(buildTaskListJsonOutput(null, statusFilter, [], []), null, 2));
+    return;
+  }
+  for (const line of formatNoActiveSprintText()) console.log(line);
+}
+async function resolveSprintId(sprintId, json, statusFilter) {
+  if (sprintId) return sprintId;
+  const current = await getCurrentSprint();
+  if (current) return current.yaml.id;
+  printNoActiveSprintEmptyState(json, statusFilter);
+  return null;
+}
+async function runTaskListAction(sprintId, options) {
+  const json = options.json === true;
+  await emitPlanningStateWarning(json);
+  const statusFilter = normalizeTaskListStatusInput(options.status);
+  if (statusFilter && !isTaskStatus(statusFilter)) {
+    const validStatuses = [...TASK_STATUSES];
+    if (json) {
+      failJson({
+        error: "invalid_status",
+        message: `Invalid --status value: ${statusFilter}`,
+        validStatuses
+      });
+    }
+    failText(
+      `Invalid --status value: ${statusFilter}`,
+      `Valid options: ${validStatuses.join(", ")}`
+    );
+  }
+  if (options.all) {
+    if (!json) {
+      failText("--all requires --json.", "Use: build plan task list --all --json");
+    }
+    if (sprintId || statusFilter) {
+      failJson({
+        error: "invalid_all_scope",
+        message: "--all cannot be combined with a sprint id or --status."
+      });
+    }
+    console.log(JSON.stringify(await getTaskCatalog(), null, 2));
+    return;
+  }
+  const resolvedSprintId = await resolveSprintId(
+    sprintId,
+    json,
+    statusFilter
+  );
+  if (!resolvedSprintId) {
+    return;
+  }
+  const sprintTaskRefs = await listTasksInSprint(resolvedSprintId);
+  const missingTaskIds = sprintTaskRefs.filter((task) => task.missing === true).map((task) => task.id);
+  const tasks = sprintTaskRefs.filter(
+    (task) => task.missing !== true && (!statusFilter || task.status === statusFilter)
+  );
+  if (json) {
+    console.log(
+      JSON.stringify(
+        buildTaskListJsonOutput(
+          resolvedSprintId,
+          statusFilter,
+          tasks,
+          missingTaskIds
+        ),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  for (const line of formatTaskListText({
+    sprintId: resolvedSprintId,
+    status: statusFilter,
+    tasks,
+    missingTaskIds
+  })) {
+    console.log(line);
+  }
+}
+function createTaskListCommand(commandPath) {
+  const task = new Command("task").description("Manage tasks");
+  task.command("list").description("List tasks in a sprint").argument("[sprint-id]", "Sprint ID (defaults to current active sprint)").option("--status <status>", "Filter by status").option("--all", "List active and archived tasks (requires --json)").option("--json", "Output JSON").action(withReadableSharedBuckets(commandPath, runTaskListAction));
+  return task;
+}
+function createTaskListFastCommand() {
+  return createTaskListCommand(["task", "list"]);
+}
+function createPlanTaskListFastCommand() {
+  const plan = new Command("plan").alias("pl").description("Work definition and organization");
+  plan.addCommand(createTaskListCommand(["plan", "task", "list"]));
+  return plan;
+}
+
+export {
+  normalizeTaskListStatusInput,
+  runTaskListAction,
+  createTaskListFastCommand,
+  createPlanTaskListFastCommand
+};
+//# sourceMappingURL=chunk-FOEINBBP.js.map

package/dist/chunk-FRBPKBFE.js

@@ -0,0 +1,30 @@
+// src/utils/format-text.ts
+function sanitizeBranchSegment(input) {
+  const trim = (value) => value.replace(/^[-/]+|[-/]+$/g, "");
+  return trim(
+    trim(
+      input.toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/[-/]*\/[-/]*/g, "/")
+    ).slice(0, 60)
+  );
+}
+function formatDurationSeconds(seconds) {
+  if (seconds === void 0 || !Number.isFinite(seconds)) return "\u2014";
+  if (seconds < 60) {
+    return `${seconds.toFixed(1)}s`;
+  }
+  const roundedSeconds = Math.round(seconds);
+  if (roundedSeconds < 3600) {
+    const minutes2 = Math.floor(roundedSeconds / 60);
+    const secs = roundedSeconds % 60;
+    return `${minutes2}m ${secs}s`;
+  }
+  const hours = Math.floor(roundedSeconds / 3600);
+  const minutes = Math.floor(roundedSeconds % 3600 / 60);
+  return `${hours}h ${minutes}m`;
+}
+
+export {
+  sanitizeBranchSegment,
+  formatDurationSeconds
+};
+//# sourceMappingURL=chunk-FRBPKBFE.js.map

package/dist/chunk-FSJ5TTZ3.js

@@ -0,0 +1,29 @@
+// src/planning/task-status-policy.ts
+function resolveTaskStatusForStageOutcome(outcome) {
+  if (outcome.kind === "stage-result") {
+    if (outcome.validationPassed) {
+      return outcome.apply ? "done" : "review";
+    }
+    return "in_progress";
+  }
+  const { event } = outcome;
+  switch (event.eventType) {
+    case "started":
+      if (outcome.stageRole === "gate") return void 0;
+      return event.attempt === 1 ? "in_progress" : void 0;
+    case "succeeded":
+      if (!event.terminal) return void 0;
+      if (outcome.stageRole === "implement" && outcome.gatePending) return "review";
+      return outcome.apply ? "done" : "review";
+    case "failed":
+      if (!event.terminal) return void 0;
+      return outcome.stageRole === "gate" ? "blocked" : "in_progress";
+    case "skipped":
+      return event.terminal ? "blocked" : void 0;
+  }
+}
+
+export {
+  resolveTaskStatusForStageOutcome
+};
+//# sourceMappingURL=chunk-FSJ5TTZ3.js.map