schub 0.1.1 → 0.1.2

package/src/commands/tasks-list.test.ts

@@ -0,0 +1,177 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const cliDir = resolve(testDir, "..", "..");
+const decoder = new TextDecoder();
+
+const runCli = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "tasks", "list", ...args],
+    cwd: cliDir,
+    env: { ...process.env, FORCE_COLOR: "0", SCHUB_CWD: schubCwd },
+  });
+
+  return {
+    result,
+    stdout: decoder.decode(result.stdout ?? new Uint8Array()),
+    stderr: decoder.decode(result.stderr ?? new Uint8Array()),
+  };
+};
+
+const createTaskRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-tasks-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+
+  const tasksRoot = join(repoRoot, ".schub", "tasks");
+  const statuses = ["backlog", "ready", "wip", "blocked", "done", "archived"];
+
+  for (const status of statuses) {
+    mkdirSync(join(tasksRoot, status), { recursive: true });
+  }
+
+  return { cwd, tasksRoot };
+};
+
+const writeTask = (tasksRoot: string, status: string, id: string, slug: string, content?: string) => {
+  const filePath = join(tasksRoot, status, `${id}_${slug}.md`);
+  const taskContent = content ?? `# ${id} ${slug}\n`;
+  writeFileSync(filePath, taskContent);
+  return filePath;
+};
+
+test("tasks list shows tasks sorted by id", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(tasksRoot, "ready", "T010", "later-task");
+  writeTask(tasksRoot, "backlog", "T002", "middle-task");
+  writeTask(tasksRoot, "archived", "T003", "archived-task");
+  writeTask(tasksRoot, "wip", "T001", "first-task");
+
+  const { result, stdout } = runCli(cwd);
+
+  expect(result.exitCode).toBe(0);
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  expect(lines).toHaveLength(4);
+  expect(lines[0]).toContain("T001");
+  expect(lines[0]).toContain("first task");
+  expect(lines[0]).toContain("(wip)");
+  expect(lines[1]).toContain("T002");
+  expect(lines[2]).toContain("T003");
+  expect(lines[3]).toContain("T010");
+});
+
+test("tasks list filters by status", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(tasksRoot, "ready", "T010", "later-task");
+  writeTask(tasksRoot, "backlog", "T002", "middle-task");
+  writeTask(tasksRoot, "wip", "T001", "first-task");
+
+  const { result, stdout } = runCli(cwd, ["--status", "ready,wip"]);
+
+  expect(result.exitCode).toBe(0);
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  expect(lines).toHaveLength(2);
+  expect(lines.join("\n")).toContain("T010");
+  expect(lines.join("\n")).toContain("T001");
+  expect(lines.join("\n")).not.toContain("T002");
+});
+
+test("tasks list supports json output", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(tasksRoot, "ready", "T010", "later-task");
+  writeTask(tasksRoot, "wip", "T001", "first-task");
+
+  const { result, stdout } = runCli(cwd, ["--json"]);
+
+  expect(result.exitCode).toBe(0);
+  const tasks = JSON.parse(stdout) as Array<{
+    id: string;
+    title: string;
+    status: string;
+    path: string;
+  }>;
+  expect(tasks[0]).toMatchObject({
+    id: "T001",
+    title: "first task",
+    status: "wip",
+  });
+  expect(tasks[0].path).toContain(".schub/tasks/wip/T001_first-task.md");
+});
+
+test("tasks list shows checklist counts in text output", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(
+    tasksRoot,
+    "wip",
+    "T001",
+    "first-task",
+    [
+      "# Task: T001 First task",
+      "",
+      "## Steps",
+      "- [ ] Draft outline",
+      "- [x] Review outline",
+      "",
+      "## Acceptance",
+      "- [ ] Not counted",
+      "",
+    ].join("\n"),
+  );
+  writeTask(tasksRoot, "backlog", "T002", "second-task");
+
+  const { result, stdout } = runCli(cwd);
+
+  expect(result.exitCode).toBe(0);
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  expect(lines).toHaveLength(2);
+  expect(lines[0]).toContain("T001");
+  expect(lines[0]).toContain("(wip)");
+  expect(lines[0]).toContain("(1/2)");
+  expect(lines[1]).toContain("T002");
+  expect(lines[1]).not.toMatch(/\(\d+\/\d+\)/);
+});
+
+test("tasks list json includes checklist counts", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(
+    tasksRoot,
+    "ready",
+    "T001",
+    "first-task",
+    ["# Task: T001 First task", "", "## Steps", "- [ ] Draft outline", "- [x] Review outline", ""].join("\n"),
+  );
+  writeTask(tasksRoot, "ready", "T002", "second-task");
+
+  const { result, stdout } = runCli(cwd, ["--json"]);
+
+  expect(result.exitCode).toBe(0);
+  const tasks = JSON.parse(stdout) as Array<{
+    id: string;
+    title: string;
+    status: string;
+    path: string;
+    checklistRemaining?: number;
+    checklistTotal?: number;
+  }>;
+  expect(tasks[0]).toMatchObject({
+    id: "T001",
+    checklistRemaining: 1,
+    checklistTotal: 2,
+  });
+  expect("checklistRemaining" in tasks[1]).toBe(false);
+  expect("checklistTotal" in tasks[1]).toBe(false);
+});
+
+test("tasks list errors without schub root", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-no-root-"));
+  const { result, stderr } = runCli(base);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain(".schub");
+});

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}>