@ordewell/core 0.7.0 → 0.7.1

package/dist/plan-utils.js

@@ -24,13 +24,17 @@ __export(plan_utils_exports, {
   EMPTY_CONVERSATION: () => EMPTY_CONVERSATION,
   EMPTY_HOLD: () => EMPTY_HOLD,
   EMPTY_TASK_LOG: () => EMPTY_TASK_LOG,
+  NOT_STARTED: () => NOT_STARTED,
   NO_TURN: () => NO_TURN,
   aheadOfDraft: () => aheadOfDraft,
+  approvalLabel: () => approvalLabel,
+  awaitingLabel: () => awaitingLabel,
   canMergeTasks: () => canMergeTasks,
   canSetDependencies: () => canSetDependencies,
   canSplitTask: () => canSplitTask,
   capConflictFiles: () => capConflictFiles,
   dependencyCandidates: () => dependencyCandidates,
+  dependentsNotice: () => dependentsNotice,
   dependentsOf: () => dependentsOf,
   diffRows: () => diffRows,
   diffStat: () => diffStat,
@@ -40,15 +44,29 @@ __export(plan_utils_exports, {
   fromTranscript: () => fromTranscript,
   hasHiddenDetail: () => hasHiddenDetail,
   holdPrompt: () => holdPrompt,
+  isTaskRunning: () => isTaskRunning,
+  markAction: () => markAction,
+  markRequestFor: () => markRequestFor,
+  namedRepos: () => namedRepos,
+  newTaskFields: () => newTaskFields,
+  opsEditable: () => opsEditable,
   outputLines: () => outputLines,
   outputPreview: () => outputPreview,
+  pastGateConfirmation: () => pastGateConfirmation,
   reduceConversation: () => reduceConversation,
   reduceTaskLog: () => reduceTaskLog,
   replayTaskLog: () => replayTaskLog,
   runnerToolSubject: () => runnerToolSubject,
   stopTurn: () => stopTurn,
   summarizeToolCall: () => summarizeToolCall,
+  taskOrderLabel: () => taskOrderLabel,
+  taskRef: () => taskRef,
+  taskRowActions: () => taskRowActions,
+  taskRowView: () => taskRowView,
   taskStartedNotice: () => taskStartedNotice,
+  taskStatusKind: () => taskStatusKind,
+  titledRefs: () => titledRefs,
+  titledTaskRef: () => titledTaskRef,
   toolHeadline: () => toolHeadline,
   truncateCheckpointSummary: () => truncateCheckpointSummary,
   unsendAll: () => unsendAll,
@@ -58,6 +76,50 @@ module.exports = __toCommonJS(plan_utils_exports);
 
 // src/services/TaskOps.ts
 var import_uuid = require("uuid");
+
+// src/order-labels.ts
+function taskOrderLabel(task, parent) {
+  return parent ? `${parent.order}.${task.order}` : String(task.order);
+}
+function taskRef(task, parent) {
+  return `#${taskOrderLabel(task, parent)}`;
+}
+function titledTaskRef(task, parent) {
+  return `${taskRef(task, parent)} ${task.title}`;
+}
+
+// src/taskRow/status.ts
+var isTaskRunning = (task) => task.status === "in_progress" || task.status === "running";
+var NOT_STARTED = /* @__PURE__ */ new Set(["pending", "approved", "blocked"]);
+function taskStatusKind(task) {
+  switch (task.status) {
+    case "completed":
+      return "done";
+    case "failed":
+      return "failed";
+    case "blocked":
+      return "blocked";
+    case "awaiting_user":
+      return "awaiting";
+  }
+  if (!isTaskRunning(task)) return "todo";
+  return task.status === "in_progress" && task.idleSince ? "quiet" : "running";
+}
+var AWAITING_LABELS = {
+  input: "Waiting for your input",
+  checkpoint: "Checkpoint",
+  conflict: "Merge conflict",
+  "files-changed": "Changed tracked files"
+};
+function awaitingLabel(task) {
+  return task.status === "awaiting_user" && task.awaitingReason ? AWAITING_LABELS[task.awaitingReason] : null;
+}
+function approvalLabel(count) {
+  if (!count) return null;
+  return count > 1 ? `Waiting for approval (${count})` : "Waiting for approval";
+}
+
+// src/services/TaskOps.ts
 function detectCycle(tasks) {
   const byId = new Map(tasks.map((t) => [t.id, t]));
   const visiting = /* @__PURE__ */ new Set();
@@ -1031,9 +1093,25 @@ function endTurn2(view, { reason }) {
   const closed = closeOpenBlocks({ ...view, working: false, lastTurnEnd: reason, streams: {} }, CUT[reason]);
   return reason === "interrupted" ? append(closed, (id) => settledMessage(id, "system", "Interrupted.")) : closed;
 }
-function queueMessage(view, { messageId, text: text2 }) {
-  if (view.queued.some((m) => m.id === messageId)) return view;
-  return { ...view, queued: [...view.queued, { id: messageId, text: text2 }] };
+function queueMessage(view, { messageId, text: text2, forced }) {
+  const listed = view.queued.find((m) => m.id === messageId);
+  if (forced) {
+    const rest = view.queued.filter((m) => m !== listed);
+    const at = rest.findIndex((m) => !m.forced);
+    const placed = at < 0 ? rest.length : at;
+    return { ...view, queued: [...rest.slice(0, placed), { id: messageId, text: text2, forced: true }, ...rest.slice(placed)] };
+  }
+  if (!listed) return { ...view, queued: [...view.queued, { id: messageId, text: text2 }] };
+  if (!listed.handedOver) return view;
+  return { ...view, queued: view.queued.map((m) => m === listed ? { id: m.id, text: m.text } : m) };
+}
+function handOver(view, { messageId }) {
+  const listed = view.queued.find((m) => m.id === messageId);
+  if (!listed || listed.handedOver) return view;
+  return { ...view, queued: view.queued.map((m) => m === listed ? { ...m, handedOver: true } : m) };
+}
+function deliverMidTurn(view, event) {
+  return appendOutput(unqueueMessage(view, event), null, (id) => settledMessage(id, "user", event.text));
 }
 function unqueueMessage(view, { messageId }) {
   const queued = view.queued.filter((m) => m.id !== messageId);
@@ -1067,6 +1145,12 @@ function reduceTaskLog(view, event) {
       return queueMessage(view, event);
     case "message_removed":
       return unqueueMessage(view, event);
+    case "message_handed_over":
+      return handOver(view, event);
+    case "message_delivered":
+      return deliverMidTurn(view, event);
+    case "message_undelivered":
+      return append(unqueueMessage(view, event), (id) => settledMessage(id, "system", `${event.text} \xB7 not delivered`));
     case "error":
       return appendOutput(view, null, (id) => settledMessage(id, "error", event.message));
     case "approval_requested":
@@ -1155,19 +1239,120 @@ function hasHiddenDetail(blocks) {
 function taskStartedNotice(title, runner) {
   return runner ? `Started "${title}" \xB7 ${runner}` : `Started "${title}"`;
 }
+
+// src/taskRow/actions.ts
+var UNSTARTED_AI = (t) => t.type === "ai" && NOT_STARTED.has(t.status);
+var QUEUED = (t) => t.status === "pending" || t.status === "approved";
+var TASK_RULES = [
+  ["cancel", (t) => t.status === "in_progress"],
+  ["skip", (t) => t.status === "blocked"],
+  ["force-start", UNSTARTED_AI],
+  // A manual task has no runner to report it done, so it can always be marked.
+  ["complete", (t) => t.status === "awaiting_user" || t.type === "user"],
+  ["uncomplete", (t) => t.status === "completed"]
+];
+var SUBTASK_RULES = [
+  ["cancel", (t) => t.status === "in_progress"],
+  ["complete", (t) => t.status === "in_progress" && t.type === "ai"],
+  ["force-start", (t) => t.type === "ai" && QUEUED(t)],
+  ["skip", QUEUED],
+  ["complete", (t) => t.status === "awaiting_user"],
+  ["uncomplete", (t) => t.status === "completed"]
+];
+function taskRowActions(task, placement = "task") {
+  const rules = placement === "subtask" ? SUBTASK_RULES : TASK_RULES;
+  return rules.filter(([, applies]) => applies(task)).map(([action]) => action);
+}
+function markAction(task) {
+  return task.status === "completed" ? "uncomplete" : "complete";
+}
+function markRequestFor(action) {
+  if (action === "complete" || action === "skip") return "complete";
+  if (action === "uncomplete") return "uncomplete";
+  return null;
+}
+function opsEditable(task) {
+  return UNSTARTED_AI(task);
+}
+
+// src/taskRow/view.ts
+var refsOf = (ids, orderOf) => ids.map((id) => {
+  const order = orderOf?.get(id);
+  return order === void 0 ? id : taskRef({ order });
+});
+var namedRepo = (repo) => repo && repo !== "." ? repo : null;
+var namedRepos = (repos) => (repos ?? []).filter((r) => r !== ".");
+var filesOf = (files) => files?.length ? capConflictFiles(files) : null;
+function taskRowView(task, context = {}) {
+  const parent = context.parent ?? void 0;
+  const isolation = task.isolation && task.isolation.state !== "none" ? task.isolation : null;
+  return {
+    orderLabel: taskOrderLabel(task, parent),
+    kind: task.type === "user" ? "user" : task.ops ? "ops" : "ai",
+    status: taskStatusKind(task),
+    running: isTaskRunning(task),
+    awaiting: awaitingLabel(task),
+    approvals: approvalLabel(task.awaitingApproval),
+    autonomous: task.type === "ai" && context.modes?.find((m) => m.id === task.taskMode)?.autonomous === true,
+    repos: namedRepos(isolation?.repos),
+    conflict: isolation?.state === "conflict" ? { repo: namedRepo(isolation.conflictRepo), files: filesOf(isolation.conflictFiles) } : null,
+    repairing: isolation?.state === "repairing" ? { files: filesOf(isolation.conflictFiles), attempt: isolation.repair ?? null } : null,
+    repaired: isolation?.repairedFiles?.length ? { files: capConflictFiles(isolation.repairedFiles), landed: isolation.state === "integrated" } : null,
+    mergeGate: task.mergeGate?.length ? refsOf(task.mergeGate, context.orderOf) : null,
+    opsChangedFiles: task.status === "awaiting_user" && task.awaitingReason === "files-changed",
+    forcedPastGate: task.forcedPastGate?.length ? task.forcedPastGate : null,
+    dependencies: refsOf(task.dependencies, context.orderOf),
+    actions: taskRowActions(task, context.placement ?? (parent ? "subtask" : "task")),
+    mark: markAction(task),
+    opsEditable: opsEditable(task)
+  };
+}
+
+// src/taskRow/texts.ts
+function findNamed(tasks, id) {
+  for (const task of tasks) {
+    if (task.id === id) return task;
+    const nested = findNamed(task.subtasks ?? [], id);
+    if (nested) return nested;
+  }
+  return void 0;
+}
+function titledRefs(ids, tasks) {
+  return ids.map((id) => {
+    const task = findNamed(tasks, id);
+    return task ? titledTaskRef(task) : id;
+  });
+}
+function dependentsNotice(dependents) {
+  if (dependents.length === 0) return null;
+  const subject = dependents.length === 1 ? "1 task depends" : `${dependents.length} tasks depend`;
+  return `${subject} on it and will lose that dependency: ${dependents.map((t) => titledTaskRef(t)).join(", ")}.`;
+}
+function pastGateConfirmation(unmerged, subject = "This task") {
+  return `${subject} waits for Merge all: the work of ${unmerged.join(", ")} is not merged into your branch yet, so it would act without it. Starting it now is kept on the task.`;
+}
+function newTaskFields(title, prompt) {
+  const name = title.trim();
+  if (!name) return null;
+  return { title: name, description: name, prompt: prompt?.trim() ? prompt : name, type: "ai" };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHECKPOINT_TRUNCATE_LENGTH,
   EMPTY_CONVERSATION,
   EMPTY_HOLD,
   EMPTY_TASK_LOG,
+  NOT_STARTED,
   NO_TURN,
   aheadOfDraft,
+  approvalLabel,
+  awaitingLabel,
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
   capConflictFiles,
   dependencyCandidates,
+  dependentsNotice,
   dependentsOf,
   diffRows,
   diffStat,
@@ -1177,15 +1362,29 @@ function taskStartedNotice(title, runner) {
   fromTranscript,
   hasHiddenDetail,
   holdPrompt,
+  isTaskRunning,
+  markAction,
+  markRequestFor,
+  namedRepos,
+  newTaskFields,
+  opsEditable,
   outputLines,
   outputPreview,
+  pastGateConfirmation,
   reduceConversation,
   reduceTaskLog,
   replayTaskLog,
   runnerToolSubject,
   stopTurn,
   summarizeToolCall,
+  taskOrderLabel,
+  taskRef,
+  taskRowActions,
+  taskRowView,
   taskStartedNotice,
+  taskStatusKind,
+  titledRefs,
+  titledTaskRef,
   toolHeadline,
   truncateCheckpointSummary,
   unsendAll,