schub 0.1.0 → 0.1.2

package/src/commands/tasks.ts

@@ -0,0 +1,172 @@
+import { resolveChangeRoot } from "../changes";
+import { createTask, listTasks, TASK_STATUSES, type TaskStatus } from "../features/tasks";
+
+const parseStatusFilter = (value: string | undefined) => {
+  if (!value) {
+    return [...TASK_STATUSES];
+  }
+
+  const normalized = value
+    .split(",")
+    .map((status) => status.trim().toLowerCase())
+    .filter(Boolean);
+
+  const allowed = new Set(TASK_STATUSES);
+  const invalid = normalized.filter((status) => !allowed.has(status as TaskStatus));
+  if (invalid.length > 0) {
+    throw new Error(`Unknown status filter: ${invalid.join(", ")}`);
+  }
+
+  return normalized as TaskStatus[];
+};
+
+const parseTaskListOptions = (args: string[]) => {
+  let statusValue: string | undefined;
+  let json = false;
+  const unknown: string[] = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--status") {
+      statusValue = args[index + 1];
+      if (!statusValue) {
+        throw new Error("Missing value for --status.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--status=")) {
+      statusValue = arg.slice("--status=".length);
+      continue;
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  return { statuses: parseStatusFilter(statusValue), json };
+};
+
+type TaskCreateOptions = {
+  changeId: string;
+  status?: string;
+  titles: string[];
+  overwrite: boolean;
+};
+
+const parseTaskCreateOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let status: string | undefined;
+  let overwrite = false;
+  const titles: string[] = [];
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--overwrite") {
+      overwrite = true;
+      continue;
+    }
+    if (arg === "--change-id") {
+      changeId = args[index + 1];
+      if (changeId === undefined) {
+        throw new Error("Missing value for --change-id.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--change-id=")) {
+      changeId = arg.slice("--change-id=".length);
+      continue;
+    }
+    if (arg === "--status") {
+      status = args[index + 1];
+      if (status === undefined) {
+        throw new Error("Missing value for --status.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--status=")) {
+      status = arg.slice("--status=".length);
+      continue;
+    }
+    if (arg === "--title") {
+      const title = args[index + 1];
+      if (title === undefined) {
+        throw new Error("Missing value for --title.");
+      }
+      titles.push(title);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--title=")) {
+      titles.push(arg.slice("--title=".length));
+      continue;
+    }
+    if (arg === "--schub-root" || arg === "--agent-root") {
+      rejectUnsupported(arg);
+    }
+    if (arg.startsWith("--schub-root=")) {
+      rejectUnsupported("--schub-root");
+    }
+    if (arg.startsWith("--agent-root=")) {
+      rejectUnsupported("--agent-root");
+    }
+    unknown.push(arg);
+  }
+
+  if (unknown.length > 0) {
+    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
+  }
+
+  if (!changeId) {
+    throw new Error("Provide --change-id.");
+  }
+
+  const options: TaskCreateOptions = { changeId, status, titles, overwrite };
+  return options;
+};
+
+export const runTasksList = (schubDir: string | null, args: string[]) => {
+  if (!schubDir) {
+    throw new Error("No .schub directory found.");
+  }
+
+  const options = parseTaskListOptions(args);
+  const tasks = listTasks(schubDir, options.statuses);
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(tasks, null, 2)}\n`);
+    return;
+  }
+
+  const lines = tasks.map((task) => {
+    const checklistSuffix =
+      typeof task.checklistRemaining === "number" && typeof task.checklistTotal === "number"
+        ? ` (${task.checklistRemaining}/${task.checklistTotal})`
+        : "";
+    return `${task.id} ${task.title} (${task.status})${checklistSuffix}`;
+  });
+  process.stdout.write(`${lines.join("\n")}\n`);
+};
+
+export const runTasksCreate = (args: string[], startDir: string) => {
+  const options = parseTaskCreateOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const created = createTask(schubDir, options);
+
+  for (const taskPath of created) {
+    process.stdout.write(`[OK] Wrote task: ${taskPath}\n`);
+  }
+};

package/src/components/PlanView.test.tsx

@@ -0,0 +1,113 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, renameSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { render } from "ink-testing-library";
+import PlanView from "./PlanView";
+
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+const stripAnsi = (value: string) => value.replace(ansiPattern, "");
+
+const extractSection = (output: string, start: string, end?: string): string => {
+  const startIndex = output.indexOf(start);
+  if (startIndex === -1) {
+    return "";
+  }
+
+  const afterStart = output.slice(startIndex + start.length);
+  if (!end) {
+    return afterStart;
+  }
+  const endIndex = afterStart.indexOf(end);
+  if (endIndex === -1) {
+    return afterStart;
+  }
+
+  return afterStart.slice(0, endIndex);
+};
+
+const noopCopy = () => {};
+
+test("plan shows backlog tasks with satisfied dependencies as ready", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-plan-view-"));
+  const tasksDir = join(base, ".schub", "tasks", "backlog");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(tasksDir, "T001_ready-task.md"), "# Task: T001 Ready Task\n", "utf8");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<PlanView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const readySection = extractSection(output, "Ready to Implement", "Dependency Plan");
+
+    expect(readySection).toContain("T001");
+    expect(readySection).not.toContain("No tasks ready for implementation.");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("plan view omits per-item shortcuts for ready tasks", () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-plan-actions-"));
+  const tasksDir = join(base, ".schub", "tasks", "backlog");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(tasksDir, "T010_quick-action.md"), "# Task: T010 Quick Action\n", "utf8");
+
+  try {
+    process.chdir(base);
+    const { lastFrame } = render(<PlanView onCopyId={noopCopy} />);
+    const output = stripAnsi(lastFrame() ?? "");
+    const readySection = extractSection(output, "Ready to Implement", "Dependency Plan");
+
+    expect(readySection).toContain("T010");
+    expect(readySection).not.toContain("[o open file]");
+    expect(readySection).not.toContain("[c copy]");
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test("plan view refreshes ready list and dependency graph when tasks change", async () => {
+  const originalCwd = process.cwd();
+  const base = mkdtempSync(join(tmpdir(), "schub-plan-refresh-"));
+  const tasksDir = join(base, ".schub", "tasks", "backlog");
+  const doneDir = join(base, ".schub", "tasks", "done");
+  const refreshIntervalMs = 50;
+  let unmount: (() => void) | undefined;
+
+  mkdirSync(tasksDir, { recursive: true });
+  mkdirSync(doneDir, { recursive: true });
+
+  try {
+    process.chdir(base);
+    writeFileSync(
+      join(tasksDir, "T002_waiting-task.md"),
+      "# Task: T002 Waiting Task\n\n**Depends on**: T003\n",
+      "utf8",
+    );
+    writeFileSync(join(tasksDir, "T003_dependency.md"), "# Task: T003 Dependency\n", "utf8");
+    const rendered = render(<PlanView refreshIntervalMs={refreshIntervalMs} onCopyId={noopCopy} />);
+    unmount = rendered.unmount;
+    const initial = stripAnsi(rendered.lastFrame() ?? "");
+    const initialReady = extractSection(initial, "Ready to Implement", "Dependency Plan");
+    expect(initialReady).not.toContain("T002");
+    const initialGraph = extractSection(initial, "Dependency Plan");
+    expect(initialGraph).toContain("T002");
+    expect(initialGraph).toContain("T003");
+
+    renameSync(join(tasksDir, "T003_dependency.md"), join(doneDir, "T003_dependency.md"));
+    await new Promise((resolve) => setTimeout(resolve, refreshIntervalMs * 2));
+
+    const refreshed = stripAnsi(rendered.lastFrame() ?? "");
+    const refreshedReady = extractSection(refreshed, "Ready to Implement", "Dependency Plan");
+    expect(refreshedReady).toContain("T002");
+    const refreshedGraph = extractSection(refreshed, "Dependency Plan");
+    expect(refreshedGraph).toContain("T002");
+    expect(refreshedGraph).not.toContain("T003");
+  } finally {
+    unmount?.();
+    process.chdir(originalCwd);
+  }
+});

package/src/components/PlanView.tsx

@@ -1,4 +1,5 @@
-import { Box, Text } from "ink";
+import { dirname } from "node:path";
+import { Box, Text, useInput } from "ink";
 import React from "react";
 import {
   buildTaskGraph,
@@ -8,36 +9,96 @@ import {
   type TaskStatus,
   trimTaskTitle,
 } from "../features/tasks";
+import { openInVsCode } from "../ide";
 
 const PLAN_TASK_STATUSES: readonly TaskStatus[] = ["backlog", "ready", "wip", "blocked"];
 const READY_TASK_STATUSES: readonly TaskStatus[] = ["backlog", "ready"];
 
-export default function PlanView() {
-  const schubDir = React.useMemo(() => findSchubRoot(), []);
-  const planData = React.useMemo(() => {
+type PlanViewProps = {
+  refreshIntervalMs?: number;
+  onCopyId: (id: string) => void;
+};
+
+const DEFAULT_REFRESH_INTERVAL_MS = 1000;
+
+const buildPlanData = (schubDir: string | null) => {
+  if (!schubDir) {
+    return { visibleTasks: [], readyTasks: [], graphLines: [] };
+  }
+
+  const allTasks = loadTaskDependencies(schubDir);
+  const visibleTasks = allTasks.filter((task) => PLAN_TASK_STATUSES.includes(task.status));
+  const tasksById = new Map(allTasks.map((task) => [task.id, task]));
+  const readyTasks = visibleTasks.filter((task) => {
+    if (!READY_TASK_STATUSES.includes(task.status)) {
+      return false;
+    }
+
+    return task.dependsOn.every((dependencyId) => tasksById.get(dependencyId)?.status === "done");
+  });
+
+  if (visibleTasks.length === 0) {
+    return { visibleTasks, readyTasks, graphLines: [] };
+  }
+
+  const graph = buildTaskGraph(visibleTasks);
+  const graphLines = renderTaskGraphLines(graph);
+  return { visibleTasks, readyTasks, graphLines };
+};
+
+export default function PlanView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, onCopyId }: PlanViewProps) {
+  const schubDir = findSchubRoot();
+  const [, setRefreshTick] = React.useState(0);
+  const planData = buildPlanData(schubDir);
+  const [selection, setSelection] = React.useState(0);
+  const totalReadyTasks = planData.readyTasks.length;
+  const repoRoot = schubDir ? dirname(schubDir) : "";
+
+  React.useEffect(() => {
     if (!schubDir) {
-      return { visibleTasks: [], readyTasks: [], graphLines: [] };
+      return;
+    }
+
+    const interval = setInterval(() => {
+      setRefreshTick((current) => current + 1);
+    }, refreshIntervalMs);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, [refreshIntervalMs, schubDir]);
+
+  React.useEffect(() => {
+    if (totalReadyTasks === 0) {
+      setSelection(0);
+      return;
     }
+    setSelection((current) => Math.min(current, totalReadyTasks - 1));
+  }, [totalReadyTasks]);
 
-    const allTasks = loadTaskDependencies(schubDir);
-    const visibleTasks = allTasks.filter((task) => PLAN_TASK_STATUSES.includes(task.status));
-    const tasksById = new Map(allTasks.map((task) => [task.id, task]));
-    const readyTasks = visibleTasks.filter((task) => {
-      if (!READY_TASK_STATUSES.includes(task.status)) {
-        return false;
-      }
+  useInput((input, key) => {
+    if (totalReadyTasks === 0) {
+      return;
+    }
 
-      return task.dependsOn.every((dependencyId) => tasksById.get(dependencyId)?.status === "done");
-    });
+    if (key.downArrow) {
+      setSelection((current) => Math.min(current + 1, totalReadyTasks - 1));
+    }
 
-    if (visibleTasks.length === 0) {
-      return { visibleTasks, readyTasks, graphLines: [] };
+    if (key.upArrow) {
+      setSelection((current) => Math.max(current - 1, 0));
     }
 
-    const graph = buildTaskGraph(visibleTasks);
-    const graphLines = renderTaskGraphLines(graph);
-    return { visibleTasks, readyTasks, graphLines };
-  }, [schubDir]);
+    if (input === "o") {
+      const selectedTask = planData.readyTasks[selection];
+      openInVsCode(repoRoot, selectedTask.path);
+    }
+
+    if (input === "c") {
+      const selectedTask = planData.readyTasks[selection];
+      onCopyId(selectedTask.id);
+    }
+  });
 
   if (!schubDir) {
     return (
@@ -66,12 +127,20 @@ export default function PlanView() {
         {planData.readyTasks.length === 0 ? (
           <Text color="gray">No tasks ready for implementation.</Text>
         ) : (
-          planData.readyTasks.map((task) => (
-            <Box key={task.id}>
-              <Text color="white">{`${task.id}`}</Text>
-              <Text color="gray"> {trimTaskTitle(task.title)}</Text>
-            </Box>
-          ))
+          planData.readyTasks.map((task, index) => {
+            const selected = index === selection;
+            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>
+                  <Text color="gray"> {trimTaskTitle(task.title)}</Text>
+                </Box>
+              </Box>
+            );
+          })
         )}
       </Box>
       <Box flexDirection="column" marginTop={2}>