schub 0.1.2 → 0.1.4

package/src/opencode.ts

@@ -0,0 +1,74 @@
+import { spawn } from "node:child_process";
+import { basename } from "node:path";
+
+type OpencodeSpawnOptions = {
+  stdio: "ignore";
+  detached: true;
+  env?: NodeJS.ProcessEnv;
+  cwd?: string;
+};
+
+type OpencodeSpawnOverrides = Partial<OpencodeSpawnOptions>;
+
+type OpencodeSpawner = (
+  command: string,
+  args: readonly string[],
+  options: OpencodeSpawnOptions,
+) => { unref: () => void };
+
+const opencodeSpawnOptions: OpencodeSpawnOptions = { stdio: "ignore", detached: true };
+
+const spawnOpencode = (
+  command: string,
+  args: readonly string[],
+  spawner: OpencodeSpawner,
+  overrides?: OpencodeSpawnOverrides,
+) => {
+  spawner(command, args, { ...opencodeSpawnOptions, ...overrides }).unref();
+};
+
+const buildSessionTitle = (repoRoot: string, label: string, id: string, detail?: string) => {
+  const trimmedDetail = detail?.trim();
+  const suffix = trimmedDetail ? ` ${trimmedDetail}` : "";
+
+  return `(${basename(repoRoot)}) ${label} ${id}${suffix}`;
+};
+
+export const buildReviewCommand = (changeId: string, repoRoot: string, changeTitle?: string) => {
+  const title = buildSessionTitle(repoRoot, "Review", changeId, changeTitle);
+
+  return {
+    command: "opencode",
+    args: ["run", "review", changeId, "--title", title],
+  };
+};
+
+export const buildImplementCommand = (taskId: string, repoRoot: string, taskTitle?: string) => {
+  const title = buildSessionTitle(repoRoot, "Implement", taskId, taskTitle);
+
+  return {
+    command: "opencode",
+    args: ["run", "implement", taskId, "--title", title],
+  };
+};
+
+export const launchOpencodeReview = (
+  changeId: string,
+  repoRoot: string,
+  overrides?: OpencodeSpawnOverrides,
+  spawner: OpencodeSpawner = spawn,
+) => {
+  const { command, args } = buildReviewCommand(changeId, repoRoot);
+  spawnOpencode(command, args, spawner, overrides);
+};
+
+export const launchOpencodeImplement = (
+  taskId: string,
+  repoRoot: string,
+  taskTitle?: string,
+  overrides?: OpencodeSpawnOverrides,
+  spawner: OpencodeSpawner = spawn,
+) => {
+  const { command, args } = buildImplementCommand(taskId, repoRoot, taskTitle);
+  spawnOpencode(command, args, spawner, overrides);
+};

package/src/tasks.ts

@@ -1,4 +1,5 @@
 export {
+  archiveTasksForChange,
   buildTaskGraph,
   findSchubRoot,
   listTasks,
@@ -12,4 +13,5 @@ export {
   type TaskInfo,
   type TaskStatus,
   trimTaskTitle,
+  updateTaskStatuses,
 } from "./features/tasks";

package/src/tui/App.test.tsx

@@ -0,0 +1,418 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { render as inkRender } from "ink-testing-library";
+import packageJson from "../../package.json";
+import { findSchubRoot } from "../features/tasks";
+import App from "./App";
+
+const schubDir = findSchubRoot(process.env.SCHUB_CWD ?? process.cwd())!;
+const homeDir = homedir();
+const displaySchubDir =
+  schubDir === homeDir ? "~" : schubDir.startsWith(`${homeDir}/`) ? `~${schubDir.slice(homeDir.length)}` : schubDir;
+
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}[[0-9;]*m`, "g");
+const stripAnsi = (value: string) => value.replace(ansiPattern, "");
+const settleFrames = async () => {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+};
+
+const renders: Array<() => void> = [];
+const render = (...args: Parameters<typeof inkRender>) => {
+  const rendered = inkRender(...args);
+  renders.push(rendered.unmount);
+  return rendered;
+};
+
+afterEach(() => {
+  for (const unmount of renders) {
+    unmount();
+  }
+  renders.length = 0;
+});
+
+const writeProposal = (changesRoot: string, changeId: string, status: string, title = changeId) => {
+  const changeDir = join(changesRoot, changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(join(changeDir, "proposal.md"), `---\nstatus: ${status}\n---\n# Proposal - ${title}\n`, "utf8");
+};
+
+const writeDetailedProposal = (changesRoot: string, changeId: string, status: string, summary: string) => {
+  const changeDir = join(changesRoot, changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(
+    join(changeDir, "proposal.md"),
+    `---\nchange_id: ${changeId}\ncreated: 2026-01-21\nstatus: ${status}\ninput: Detail view\n---\n# Proposal - ${changeId}\n\n## Summary\n\n${summary}\n`,
+    "utf8",
+  );
+};
+
+const writeTask = (tasksRoot: string, id: string, slug: string, body: string) => {
+  const filePath = join(tasksRoot, `${id}_${slug}.md`);
+  writeFileSync(filePath, body, "utf8");
+};
+test("renders tabs with header and footer details", () => {
+  const { lastFrame } = render(<App />);
+  const output = stripAnsi(lastFrame() || "");
+  expect(output).toContain("Status");
+  expect(output).toContain("Plan");
+  expect(output).toContain("Roadmap");
+  expect(output).toContain("switch mode");
+  expect(output).toContain(displaySchubDir);
+  expect(output).toContain(packageJson.version);
+});
+test("shows open and copy shortcuts only when selection is openable", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-open-shortcuts-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+
+  mkdirSync(changesRoot, { recursive: true });
+  mkdirSync(readyRoot, { recursive: true });
+
+  writeProposal(changesRoot, "C0102_openable", "Draft", "Openable Proposal");
+  writeTask(readyRoot, "T0102", "ready-task", "# Task: T0102 Ready Task\n");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  const initial = stripAnsi(rendered.lastFrame() ?? "");
+  expect(initial).toContain("[o preview]");
+  expect(initial).toContain("[c copy id]");
+
+  rendered.stdin.write("\u001B[B");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  const moved = stripAnsi(rendered.lastFrame() ?? "");
+  expect(moved).not.toContain("[o preview]");
+  expect(moved).not.toContain("[c copy id]");
+});
+test("opens preview from status view and returns on escape", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-preview-"));
+  const backlogRoot = join(baseDir, ".schub", "tasks", "backlog");
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0104", "preview-task", "# Task: T0104 Preview Task\n\n## Notes\nHello preview\n");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await settleFrames();
+  rendered.stdin.write("o");
+  await settleFrames();
+
+  let output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("T0104_preview-task.md");
+  expect(output).toContain("Hello preview");
+
+  rendered.stdin.write("\u001B");
+  await settleFrames();
+  output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("Change Proposals");
+});
+test("keeps show-all tasks active when preview closes", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-preview-show-all-"));
+  const backlogRoot = join(baseDir, ".schub", "tasks", "backlog");
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0105", "preview-task", "# Task: T0105 Preview Task\n\n## Notes\nHello show all\n");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await settleFrames();
+  rendered.stdin.write("t");
+  await settleFrames();
+  rendered.stdin.write("o");
+  await settleFrames();
+
+  let output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("T0105_preview-task.md");
+
+  rendered.stdin.write("\t");
+  await settleFrames();
+  rendered.stdin.write("\u001B");
+  await settleFrames();
+
+  output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("All Tasks");
+  expect(output).not.toContain("Dependency Plan");
+});
+
+test("opens proposal detail from status view and returns on escape", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-detail-view-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+  const changeId = "C1400_detail-view";
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeDetailedProposal(changesRoot, changeId, "Draft", "Detail view summary.");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await settleFrames();
+
+  rendered.stdin.write("\n");
+  await settleFrames();
+
+  let output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("Proposal Detail");
+
+  rendered.stdin.write("\u001B");
+  await settleFrames();
+
+  output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("Change Proposals");
+});
+
+test("detail view exposes open and copy shortcuts for tasks", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-detail-shortcuts-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+  const backlogRoot = join(baseDir, ".schub", "tasks", "backlog");
+  const changeId = "C1401_detail-actions";
+  let copied = "";
+
+  mkdirSync(changesRoot, { recursive: true });
+  mkdirSync(backlogRoot, { recursive: true });
+
+  writeDetailedProposal(changesRoot, changeId, "Draft", "Detail action summary.");
+  writeTask(
+    backlogRoot,
+    "T1400",
+    "detail-task",
+    `---\nchange_id: ${changeId}\n---\n# Task: T1400 Detail Task\n\n## Notes\n\nHello detail\n`,
+  );
+
+  const rendered = render(
+    <App
+      startDir={baseDir}
+      copyToClipboard={(value) => {
+        copied = value;
+      }}
+    />,
+  );
+
+  await settleFrames();
+  rendered.stdin.write("\n");
+  await settleFrames();
+
+  const detailOutput = stripAnsi(rendered.lastFrame() ?? "");
+  expect(detailOutput).toContain("[o preview]");
+  expect(detailOutput).toContain("[c copy id]");
+
+  rendered.stdin.write("c");
+  await settleFrames();
+  expect(copied).toBe("T1400");
+
+  rendered.stdin.write("o");
+  await settleFrames();
+
+  const previewOutput = stripAnsi(rendered.lastFrame() ?? "");
+  expect(previewOutput).toContain("T1400_detail-task.md");
+  expect(previewOutput).toContain("Hello detail");
+});
+test("hides tabs in show-all proposals view", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-show-all-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, "C0100_show-all", "Draft", "Show All Proposal");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("p");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  const output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("All Proposals");
+  expect(output).not.toContain("Status");
+  expect(output).not.toContain("Plan");
+  expect(output).not.toContain("switch mode");
+});
+test("hides tabs in show-all tasks view", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-show-all-tasks-"));
+  const backlogRoot = join(baseDir, ".schub", "tasks", "backlog");
+
+  mkdirSync(backlogRoot, { recursive: true });
+  writeTask(backlogRoot, "T0100", "task", "# Task: T0100 Task\n");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("t");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  const output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("All Tasks");
+  expect(output).not.toContain("Status");
+  expect(output).not.toContain("Plan");
+  expect(output).not.toContain("switch mode");
+});
+test("ignores tab while showing all proposals", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-show-all-tab-"));
+  const changesRoot = join(baseDir, ".schub", "changes");
+
+  mkdirSync(changesRoot, { recursive: true });
+  writeProposal(changesRoot, "C0101_show-all", "Draft", "Show All Proposal");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("p");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("\t");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  const output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("All Proposals");
+});
+test("shows implement shortcut when ready to implement task is selected", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-implement-shortcut-"));
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+  const doneRoot = join(baseDir, ".schub", "tasks", "done");
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0500", "done-task", "# Task: T0500 Done Task\n");
+  writeTask(readyRoot, "T0501", "ready-task", "---\ndepends_on:\n  - T0500\n---\n# Task: T0501 Ready Task\n");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const output = stripAnsi(rendered.lastFrame() ?? "");
+  expect(output).toContain("[i implement]");
+});
+test("hides implement shortcut when selection moves off ready to implement", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-implement-hide-"));
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+  const doneRoot = join(baseDir, ".schub", "tasks", "done");
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0502", "done-task", "# Task: T0502 Done Task\n");
+  writeTask(readyRoot, "T0503", "ready-task", "---\ndepends_on:\n  - T0502\n---\n# Task: T0503 Ready Task\n");
+
+  const rendered = render(<App startDir={baseDir} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const initial = stripAnsi(rendered.lastFrame() ?? "");
+  expect(initial).toContain("[i implement]");
+
+  rendered.stdin.write("\u001B[B");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const moved = stripAnsi(rendered.lastFrame() ?? "");
+  expect(moved).not.toContain("[i implement]");
+});
+test("triggers implement helper for ready selection", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-implement-action-"));
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+  const doneRoot = join(baseDir, ".schub", "tasks", "done");
+  let didImplement = false;
+  let implemented = { id: "", repoRoot: "" };
+
+  const recordImplement = (id: string, repoRoot: string) => {
+    implemented = { id, repoRoot };
+    didImplement = true;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0600", "done-task", "# Task: T0600 Done Task\n");
+  writeTask(readyRoot, "T0601", "ready-task", "---\ndepends_on:\n  - T0600\n---\n# Task: T0601 Ready Task\n");
+
+  const rendered = render(<App startDir={baseDir} onImplement={recordImplement} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("i");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  expect(didImplement).toBe(true);
+  expect(implemented.id).toBe("T0601");
+  expect(realpathSync(implemented.repoRoot)).toBe(realpathSync(baseDir));
+});
+test("ignores implement helper when selection is not ready", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-implement-noop-"));
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+  const blockedRoot = join(baseDir, ".schub", "tasks", "blocked");
+  const doneRoot = join(baseDir, ".schub", "tasks", "done");
+  let didImplement = false;
+
+  const recordImplement = () => {
+    didImplement = true;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  mkdirSync(blockedRoot, { recursive: true });
+  mkdirSync(doneRoot, { recursive: true });
+
+  writeTask(doneRoot, "T0602", "done-task", "# Task: T0602 Done Task\n");
+  writeTask(readyRoot, "T0603", "ready-task", "---\ndepends_on:\n  - T0602\n---\n# Task: T0603 Ready Task\n");
+  writeTask(blockedRoot, "T0604", "blocked-task", "# Task: T0604 Blocked Task\n");
+
+  const rendered = render(<App startDir={baseDir} onImplement={recordImplement} />);
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("\u001B[B");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  rendered.stdin.write("i");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  expect(didImplement).toBe(false);
+});
+test("selected tab shows a blue left indicator", () => {
+  const originalForceColor = process.env.FORCE_COLOR;
+  process.env.FORCE_COLOR = "1";
+
+  try {
+    const { lastFrame } = render(<App />);
+    const output = lastFrame() || "";
+    const statusLine = output.split("\n").find((line) => line.includes("Status")) ?? "";
+    expect(statusLine).toContain("Status");
+    expect(statusLine).not.toContain("│");
+  } finally {
+    if (originalForceColor === undefined) {
+      delete process.env.FORCE_COLOR;
+    } else {
+      process.env.FORCE_COLOR = originalForceColor;
+    }
+  }
+});
+test("shows a copy banner after copying an item", async () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-copy-"));
+  const readyRoot = join(baseDir, ".schub", "tasks", "ready");
+  let copied = "";
+  const recordCopy = (value: string) => {
+    copied = value;
+  };
+
+  mkdirSync(readyRoot, { recursive: true });
+  writeFileSync(join(readyRoot, "T0900_copy-task.md"), "# Task: T0900 Copy Task\n", "utf8");
+
+  const rendered = render(<App startDir={baseDir} copyToClipboard={recordCopy} />);
+  rendered.stdin.write("c");
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const output = rendered.lastFrame() ?? "";
+  expect(copied).toBe("T0900");
+  expect(output).toContain("Copied to clipboard !");
+});
+test("renders when no .schub directory is found", () => {
+  const baseDir = mkdtempSync(join(tmpdir(), "schub-app-"));
+  const { lastFrame } = render(<App startDir={baseDir} />);
+  const output = lastFrame() ?? "";
+  expect(output).toContain("No .schub directory found.");
+});