schub 0.1.2 → 0.1.4

package/src/tui/components/status-view-data.ts

@@ -0,0 +1,322 @@
+import { normalize, sep } from "node:path";
+import {
+  type ChangeInfo,
+  type ChangeOverviewInfo,
+  listChangeOverview,
+  listChanges,
+  updateChangeStatus,
+} from "../../changes";
+import {
+  listTasks,
+  loadTaskDependencies,
+  TASK_STATUSES,
+  type TaskInfo,
+  type TaskStatus,
+  trimTaskTitle,
+} from "../../features/tasks";
+
+type ChangeTaskCount = {
+  completed: number;
+  total: number;
+};
+
+type ChangeSortable = {
+  id: string;
+  title: string;
+};
+
+export type StatusGroup = {
+  label: string;
+  order: number;
+  items: ChangeOverviewInfo[];
+};
+
+export type TaskStatusGroup = {
+  label: string;
+  order: number;
+  items: TaskInfo[];
+};
+
+const TASK_STATUS_LABELS: Record<TaskStatus, string> = {
+  backlog: "Backlog",
+  ready: "Ready",
+  wip: "WIP",
+  blocked: "Blocked",
+  done: "Done",
+  archived: "Archived",
+};
+
+const ACTIVE_TASK_STATUSES = ["blocked", "wip", "ready", "backlog"] as const;
+const CHANGE_TASK_STATUSES = [...ACTIVE_TASK_STATUSES, "done"] as const;
+const READY_TO_IMPLEMENT_STATUSES = new Set(["backlog", "ready"]);
+const AUTO_MARK_STATUSES = new Set(["accepted", "wip"]);
+
+const compareText = (left: string, right: string): number =>
+  left.localeCompare(right, undefined, { sensitivity: "base" });
+
+const taskSortTitle = (task: TaskInfo) => {
+  if (task.status === "blocked") {
+    const reason = task.blockedReason?.trim();
+    if (reason) {
+      return reason;
+    }
+  }
+
+  const title = trimTaskTitle(task.title);
+  return title || task.id;
+};
+
+const changeSortTitle = (change: ChangeSortable) => {
+  const title = formatChangeTitle(change.id, change.title);
+  return title || change.id;
+};
+
+const sortByTaskTitle = (left: TaskInfo, right: TaskInfo): number => {
+  const titleCompare = compareText(taskSortTitle(left), taskSortTitle(right));
+  if (titleCompare !== 0) {
+    return titleCompare;
+  }
+
+  return compareText(left.id, right.id);
+};
+
+export const formatChangeId = (value: string) => {
+  const match = value.match(/^([Cc]\d+)_/);
+  return match ? match[1].toUpperCase() : value;
+};
+
+export const formatChangeTitle = (changeId: string, title: string) => {
+  const trimmedTitle = title.trim();
+  if (trimmedTitle !== changeId) {
+    return trimmedTitle;
+  }
+
+  const match = changeId.match(/^([Cc]\d+)_(.+)$/);
+  if (!match) {
+    return trimmedTitle;
+  }
+
+  return match[2]
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+};
+
+const sortByChangeTitle = (left: ChangeSortable, right: ChangeSortable) => {
+  const titleCompare = compareText(changeSortTitle(left), changeSortTitle(right));
+  if (titleCompare !== 0) {
+    return titleCompare;
+  }
+  return compareText(left.id, right.id);
+};
+
+const groupChangesByStatus = (changes: ChangeOverviewInfo[]) => {
+  const grouped = new Map<string, StatusGroup>();
+  for (const change of changes) {
+    const key = `${change.statusOrder}-${change.statusLabel}`;
+    const current = grouped.get(key) ?? {
+      label: change.statusLabel,
+      order: change.statusOrder,
+      items: [],
+    };
+    current.items.push(change);
+    grouped.set(key, current);
+  }
+  const sorted = Array.from(grouped.values()).sort((left, right) => {
+    const orderCompare = left.order - right.order;
+    if (orderCompare !== 0) {
+      return orderCompare;
+    }
+    return compareText(left.label, right.label);
+  });
+  for (const group of sorted) {
+    group.items.sort(sortByChangeTitle);
+  }
+  return sorted;
+};
+
+export const buildShowAllGroups = (schubDir: string | null) => {
+  if (!schubDir) {
+    return [];
+  }
+  return groupChangesByStatus(listChangeOverview(schubDir));
+};
+
+const buildTaskStatusGroups = (tasks: TaskInfo[]): TaskStatusGroup[] => {
+  const groups = new Map<TaskStatus, TaskStatusGroup>();
+
+  TASK_STATUSES.forEach((status, index) => {
+    groups.set(status, {
+      label: TASK_STATUS_LABELS[status],
+      order: index,
+      items: [],
+    });
+  });
+
+  for (const task of tasks) {
+    const group = groups.get(task.status);
+    if (group) {
+      group.items.push(task);
+    }
+  }
+
+  for (const group of groups.values()) {
+    group.items.sort(sortByTaskTitle);
+  }
+
+  return TASK_STATUSES.map((status) => groups.get(status))
+    .filter((group): group is TaskStatusGroup => Boolean(group))
+    .filter((group) => group.items.length > 0);
+};
+
+export const buildShowAllTaskGroups = (schubDir: string | null) => {
+  if (!schubDir) {
+    return [];
+  }
+
+  return buildTaskStatusGroups(listTasks(schubDir, TASK_STATUSES));
+};
+
+export const isTaskItem = (item: ChangeInfo | TaskInfo): item is TaskInfo => {
+  const parts = normalize(item.path).split(sep);
+  return parts.includes("tasks");
+};
+
+const canAutoMarkChange = (status: string) => AUTO_MARK_STATUSES.has(status.trim().toLowerCase());
+
+export const autoMarkChangesDone = (schubDir: string) => {
+  const allTasks = loadTaskDependencies(schubDir, CHANGE_TASK_STATUSES);
+  const changeTaskCounts = new Map<string, ChangeTaskCount>();
+
+  for (const task of allTasks) {
+    if (!task.changeId) {
+      continue;
+    }
+
+    const current = changeTaskCounts.get(task.changeId) ?? { completed: 0, total: 0 };
+    const completed = current.completed + (task.status === "done" ? 1 : 0);
+    changeTaskCounts.set(task.changeId, { completed, total: current.total + 1 });
+  }
+
+  if (changeTaskCounts.size === 0) {
+    return;
+  }
+
+  for (const change of listChanges(schubDir)) {
+    const counts = changeTaskCounts.get(change.id);
+    if (!counts || counts.total === 0 || counts.completed !== counts.total) {
+      continue;
+    }
+
+    if (canAutoMarkChange(change.status)) {
+      updateChangeStatus(schubDir, change.id, "Done");
+    }
+  }
+};
+
+export const buildStatusData = (schubDir: string | null) => {
+  if (!schubDir) {
+    return {
+      pendingReview: [],
+      pendingImplementation: [],
+      pendingImplementationNoTasks: [],
+      drafts: [],
+      readyToImplement: [],
+      blocked: [],
+      wip: [],
+      ready: [],
+      backlog: [],
+      pendingImplementationCounts: new Map<string, string>(),
+    };
+  }
+
+  const allTasks = loadTaskDependencies(schubDir, CHANGE_TASK_STATUSES);
+  const tasksById = new Map(allTasks.map((task) => [task.id, task]));
+
+  const blockedTasks: TaskInfo[] = [];
+  const wipTasks: TaskInfo[] = [];
+  const readyTasks: TaskInfo[] = [];
+  const backlogTasks: TaskInfo[] = [];
+
+  const activeChangeIds = new Set<string>();
+  const changeTaskCounts = new Map<string, ChangeTaskCount>();
+
+  for (const task of allTasks) {
+    if (task.status === "blocked") blockedTasks.push(task);
+    else if (task.status === "wip") wipTasks.push(task);
+    else if (task.status === "ready") readyTasks.push(task);
+    else if (task.status === "backlog") backlogTasks.push(task);
+
+    if (task.changeId && task.status !== "done") {
+      activeChangeIds.add(task.changeId);
+    }
+
+    if (task.changeId) {
+      const current = changeTaskCounts.get(task.changeId) ?? { completed: 0, total: 0 };
+      const completed = current.completed + (task.status === "done" ? 1 : 0);
+      changeTaskCounts.set(task.changeId, { completed, total: current.total + 1 });
+    }
+  }
+
+  const readyToImplementTasks = allTasks
+    .filter((task) => READY_TO_IMPLEMENT_STATUSES.has(task.status))
+    .filter((task) => task.dependsOn.every((dependencyId) => tasksById.get(dependencyId)?.status === "done"))
+    .sort(sortByTaskTitle);
+
+  const allChanges = listChanges(schubDir);
+  const pendingReviewChanges: ChangeInfo[] = [];
+  const pendingImplementationChanges: ChangeInfo[] = [];
+  const draftChanges: ChangeInfo[] = [];
+
+  for (const change of allChanges) {
+    const normalized = change.status.toLowerCase();
+    if (normalized.includes("review")) {
+      pendingReviewChanges.push(change);
+      continue;
+    }
+
+    const counts = changeTaskCounts.get(change.id);
+    const allTasksCompleted = Boolean(counts && counts.total > 0 && counts.completed === counts.total);
+
+    if (activeChangeIds.has(change.id)) {
+      pendingImplementationChanges.push(change);
+      continue;
+    }
+
+    if ((normalized.includes("implementing") || normalized.includes("accepted")) && !allTasksCompleted) {
+      pendingImplementationChanges.push(change);
+      continue;
+    }
+
+    if (normalized.includes("draft")) {
+      draftChanges.push(change);
+    }
+  }
+
+  const pendingImplementationWithTasks: ChangeInfo[] = [];
+  const pendingImplementationNoTasks: ChangeInfo[] = [];
+  const pendingImplementationCounts = new Map<string, string>();
+
+  for (const change of pendingImplementationChanges.sort(sortByChangeTitle)) {
+    const counts = changeTaskCounts.get(change.id);
+    if (counts && counts.total > 0) {
+      pendingImplementationWithTasks.push(change);
+      pendingImplementationCounts.set(change.id, `${counts.completed}/${counts.total}`);
+    } else {
+      pendingImplementationNoTasks.push(change);
+    }
+  }
+
+  return {
+    pendingReview: pendingReviewChanges.sort(sortByChangeTitle),
+    pendingImplementation: pendingImplementationWithTasks,
+    pendingImplementationNoTasks,
+    drafts: draftChanges.sort(sortByChangeTitle),
+    readyToImplement: readyToImplementTasks,
+    blocked: blockedTasks.sort(sortByTaskTitle),
+    wip: wipTasks.sort(sortByTaskTitle),
+    ready: readyTasks.sort(sortByTaskTitle),
+    backlog: backlogTasks.sort(sortByTaskTitle),
+    pendingImplementationCounts,
+  };
+};

package/src/tui/components/status-view-render.tsx

@@ -0,0 +1,329 @@
+import { Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import type { ChangeInfo } from "../../changes";
+import { type TaskInfo, trimTaskTitle } from "../../features/tasks";
+import {
+  formatChangeId,
+  formatChangeTitle,
+  isTaskItem,
+  type StatusGroup,
+  type TaskStatusGroup,
+} from "./status-view-data";
+
+export type ShowAllRow = {
+  kind: "show-all";
+  id: string;
+  title: string;
+};
+
+export type StatusItem = ChangeInfo | TaskInfo | ShowAllRow;
+
+export const isShowAllRow = (item: StatusItem | null): item is ShowAllRow =>
+  Boolean(item && "kind" in item && item.kind === "show-all");
+
+type MainViewProps = {
+  selection: number;
+  pendingReview: ChangeInfo[];
+  pendingImplementation: ChangeInfo[];
+  pendingImplementationNoTasks: ChangeInfo[];
+  drafts: ChangeInfo[];
+  pendingImplementationCounts: Map<string, string>;
+  readyToImplement: TaskInfo[];
+  blocked: TaskInfo[];
+  wip: TaskInfo[];
+  ready: TaskInfo[];
+  backlog: TaskInfo[];
+  showAllRow: ShowAllRow;
+  showAllTasksRow: ShowAllRow;
+};
+
+export const StatusMainView = ({
+  selection,
+  pendingReview,
+  pendingImplementation,
+  pendingImplementationNoTasks,
+  drafts,
+  pendingImplementationCounts,
+  readyToImplement,
+  blocked,
+  wip,
+  ready,
+  backlog,
+  showAllRow,
+  showAllTasksRow,
+}: MainViewProps) => {
+  const renderRow = (item: StatusItem, index: number, detail?: string) => {
+    const selected = index === selection;
+
+    if (isShowAllRow(item)) {
+      return (
+        <Box key={item.id} marginLeft={1}>
+          <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
+          <Box marginLeft={1}>
+            <Text color="white" bold={selected}>
+              {item.title}
+            </Text>
+          </Box>
+        </Box>
+      );
+    }
+
+    const task = isTaskItem(item) ? item : null;
+    const title = task ? trimTaskTitle(task.title) : "";
+    const isBlockedTask = task?.status === "blocked";
+    const blockedReason = isBlockedTask ? task.blockedReason?.trim() : undefined;
+    const checklistIndicator =
+      task && task.status === "wip" && typeof task.checklistTotal === "number"
+        ? ` (${task.checklistRemaining ?? 0}/${task.checklistTotal})`
+        : "";
+    const changeTitle = task ? "" : formatChangeTitle(item.id, item.title);
+    const changeDetail = detail ? ` ${detail}` : "";
+    const taskTitle = task ? (isBlockedTask ? (blockedReason ?? "") : `${title}${checklistIndicator}`) : "";
+    const displayTitle = task ? taskTitle : `${changeTitle}${changeDetail}`.trim();
+    const displayId = task ? item.id : formatChangeId(item.id);
+    const showSpinner = task?.status === "wip";
+
+    return (
+      <Box key={item.id} marginLeft={1}>
+        <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
+        <Box marginLeft={1}>
+          <Text color="white" bold={selected}>
+            {displayId}
+          </Text>
+          {displayTitle ? <Text color="gray"> {displayTitle}</Text> : null}
+          {showSpinner ? (
+            <Box marginLeft={1}>
+              <Spinner />
+            </Box>
+          ) : null}
+        </Box>
+      </Box>
+    );
+  };
+
+  let currentIndex = 0;
+
+  const renderSection = (title: string, items: StatusItem[], detailById?: Map<string, string>, emptyState?: string) => {
+    if (items.length === 0) {
+      if (!emptyState) {
+        return null;
+      }
+
+      return (
+        <Box flexDirection="column" marginBottom={1}>
+          <Box marginBottom={0}>
+            <Text color="white">{title}</Text>
+          </Box>
+          <Box marginLeft={1}>
+            <Text color="gray">{emptyState}</Text>
+          </Box>
+        </Box>
+      );
+    }
+
+    const sectionStartIndex = currentIndex;
+    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i, detailById?.get(item.id)));
+    currentIndex += items.length;
+
+    return (
+      <Box flexDirection="column" marginBottom={1}>
+        <Box marginBottom={0}>
+          <Text color="white">{title}</Text>
+        </Box>
+        {sectionItems}
+      </Box>
+    );
+  };
+
+  const renderShowAllRow = (row: ShowAllRow) => {
+    const rowIndex = currentIndex;
+    currentIndex += 1;
+
+    return (
+      <Box flexDirection="column" marginBottom={1}>
+        {renderRow(row, rowIndex)}
+      </Box>
+    );
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box flexDirection="column" marginBottom={1}>
+        <Box marginBottom={1}>
+          <Text bold color="white">
+            Change Proposals
+          </Text>
+        </Box>
+        {renderSection("Pending Review", pendingReview)}
+        {renderSection("Pending Implementation", pendingImplementation, pendingImplementationCounts)}
+        {renderSection("No Tasks Defined", pendingImplementationNoTasks)}
+        {renderSection("Drafts", drafts)}
+        {pendingReview.length === 0 &&
+          pendingImplementation.length === 0 &&
+          pendingImplementationNoTasks.length === 0 &&
+          drafts.length === 0 && (
+            <Box marginLeft={1}>
+              <Text color="gray">No active proposals.</Text>
+            </Box>
+          )}
+        {renderShowAllRow(showAllRow)}
+      </Box>
+
+      <Box flexDirection="column">
+        <Box marginBottom={1}>
+          <Text bold color="white">
+            Tasks
+          </Text>
+        </Box>
+        {renderSection("Ready to Implement", readyToImplement, undefined, "No tasks ready for implementation.")}
+        {renderSection("Blocked", blocked)}
+        {renderSection("WIP", wip)}
+        {renderSection("Ready", ready)}
+        {renderSection("Backlog", backlog)}
+        {blocked.length === 0 && wip.length === 0 && ready.length === 0 && backlog.length === 0 && (
+          <Box marginLeft={1}>
+            <Text color="gray">No active tasks.</Text>
+          </Box>
+        )}
+        {renderShowAllRow(showAllTasksRow)}
+      </Box>
+    </Box>
+  );
+};
+
+type ShowAllViewProps = {
+  selection: number;
+  showAllGroups: StatusGroup[];
+};
+
+export const StatusShowAllView = ({ selection, showAllGroups }: ShowAllViewProps) => {
+  const renderRow = (item: ChangeInfo, index: number) => {
+    const selected = index === selection;
+    const displayId = formatChangeId(item.id);
+    const displayTitle = formatChangeTitle(item.id, item.title);
+
+    return (
+      <Box key={item.id} marginLeft={1}>
+        <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
+        <Box marginLeft={1}>
+          <Text color="white" bold={selected}>
+            {displayId}
+          </Text>
+          {displayTitle ? <Text color="gray"> {displayTitle}</Text> : null}
+        </Box>
+      </Box>
+    );
+  };
+
+  let showAllIndex = 0;
+
+  const renderShowAllSection = (title: string, items: ChangeInfo[]) => {
+    if (items.length === 0) return null;
+
+    const sectionStartIndex = showAllIndex;
+    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i));
+    showAllIndex += items.length;
+
+    return (
+      <Box key={title} flexDirection="column" marginBottom={1}>
+        <Box marginBottom={0}>
+          <Text color="white">{title}</Text>
+        </Box>
+        {sectionItems}
+      </Box>
+    );
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1} flexDirection="row">
+        <Text bold color="white">
+          All Proposals
+        </Text>
+        <Text color="gray"> · esc to return</Text>
+      </Box>
+      {showAllGroups.length === 0 ? (
+        <Box marginLeft={1}>
+          <Text color="gray">No proposals found.</Text>
+        </Box>
+      ) : (
+        showAllGroups.map((group) => renderShowAllSection(group.label, group.items))
+      )}
+    </Box>
+  );
+};
+
+type ShowAllTasksViewProps = {
+  selection: number;
+  showAllTaskGroups: TaskStatusGroup[];
+};
+
+export const StatusShowAllTasksView = ({ selection, showAllTaskGroups }: ShowAllTasksViewProps) => {
+  const renderRow = (task: TaskInfo, index: number) => {
+    const selected = index === selection;
+    const title = trimTaskTitle(task.title);
+    const isBlockedTask = task.status === "blocked";
+    const blockedReason = isBlockedTask ? task.blockedReason?.trim() : undefined;
+    const checklistIndicator =
+      task.status === "wip" && typeof task.checklistTotal === "number"
+        ? ` (${task.checklistRemaining ?? 0}/${task.checklistTotal})`
+        : "";
+    const taskTitle = isBlockedTask ? (blockedReason ?? "") : `${title}${checklistIndicator}`;
+    const displayTitle = taskTitle.trim();
+    const showSpinner = task.status === "wip";
+
+    return (
+      <Box key={task.id} marginLeft={1}>
+        <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
+        <Box marginLeft={1}>
+          <Text color="white" bold={selected}>
+            {task.id}
+          </Text>
+          {displayTitle ? <Text color="gray"> {displayTitle}</Text> : null}
+          {showSpinner ? (
+            <Box marginLeft={1}>
+              <Spinner />
+            </Box>
+          ) : null}
+        </Box>
+      </Box>
+    );
+  };
+
+  let showAllIndex = 0;
+
+  const renderShowAllSection = (group: TaskStatusGroup) => {
+    if (group.items.length === 0) return null;
+
+    const sectionStartIndex = showAllIndex;
+    const sectionItems = group.items.map((item, i) => renderRow(item, sectionStartIndex + i));
+    showAllIndex += group.items.length;
+
+    return (
+      <Box key={group.label} flexDirection="column" marginBottom={1}>
+        <Box marginBottom={0}>
+          <Text color="white">{group.label}</Text>
+        </Box>
+        {sectionItems}
+      </Box>
+    );
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1} flexDirection="row">
+        <Text bold color="white">
+          All Tasks
+        </Text>
+        <Text color="gray"> · esc to return</Text>
+      </Box>
+      {showAllTaskGroups.length === 0 ? (
+        <Box marginLeft={1}>
+          <Text color="gray">No tasks found.</Text>
+        </Box>
+      ) : (
+        showAllTaskGroups.map((group) => renderShowAllSection(group))
+      )}
+    </Box>
+  );
+};

package/src/tui/index.ts

@@ -0,0 +1,16 @@
+import { render } from "ink";
+import React from "react";
+import App from "./App";
+import { applyTerminalPrelude, applyTerminalReset } from "./terminal";
+
+const registerTerminalReset = () => {
+  process.once("exit", () => {
+    applyTerminalReset();
+  });
+};
+
+export const runTui = () => {
+  applyTerminalPrelude();
+  registerTerminalReset();
+  render(React.createElement(App));
+};

package/templates/create-proposal/adr-template.md

@@ -1,8 +1,10 @@
-# ADR: [TITLE]
+---
+status: "[Proposed | Accepted | Deprecated | Superseded]"
+date: "[YYYY-MM-DD]"
+related: "[PR link, spec link, plan link, issue link]"
+---
 
-**Status**: [Proposed | Accepted | Deprecated | Superseded]  
-**Date**: [YYYY-MM-DD]  
-**Related**: [PR link, spec link, plan link, issue link]
+# ADR: [TITLE]
 
 > Use ADRs to capture the **WHY**, not the implementation details.
 > Keep it short and specific: context → decision → rationale → consequences.

package/templates/create-proposal/cookbook-template.md

@@ -1,7 +1,9 @@
-# Cookbook - {{CHANGE_TITLE}}
+---
+change_id: "{{CHANGE_ID}}"
+created: "{{DATE}}"
+---
 
-**Change ID**: `{{CHANGE_ID}}`
-**Created**: {{DATE}}
+# Cookbook - {{CHANGE_TITLE}}
 
 ## Overview