schub 0.1.0 → 0.1.2

package/src/commands/review.ts

@@ -0,0 +1,231 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isValidChangeId, normalizeChangeId, readChangeSummary, resolveChangeRoot } from "../changes";
+import { resolveTemplatePath } from "../templates";
+
+const BUNDLED_REVIEW_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../templates/review-proposal/review-me-template.md", import.meta.url),
+);
+const BUNDLED_QNA_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../templates/review-proposal/q&a-template.md", import.meta.url),
+);
+
+type ReviewCreateOptions = {
+  changeId: string;
+  title?: string;
+  output?: string;
+  overwrite: boolean;
+};
+
+type ReviewCompleteOptions = {
+  changeId: string;
+  overwrite: boolean;
+};
+
+const renderChangeTemplate = (template: string, changeTitle: string, changeId: string) => {
+  const today = new Date().toISOString().split("T")[0];
+  return template
+    .replace("{{CHANGE_TITLE}}", changeTitle)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today);
+};
+
+const parseReviewCreateOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let title: string | undefined;
+  let output: string | undefined;
+  let overwrite = false;
+  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 === "--title") {
+      title = args[index + 1];
+      if (title === undefined) {
+        throw new Error("Missing value for --title.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--title=")) {
+      title = arg.slice("--title=".length);
+      continue;
+    }
+    if (arg === "--output") {
+      output = args[index + 1];
+      if (output === undefined) {
+        throw new Error("Missing value for --output.");
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--output=")) {
+      output = arg.slice("--output=".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.");
+  }
+
+  return { changeId, title, output, overwrite };
+};
+
+const parseReviewCompleteOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let overwrite = false;
+  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 === "--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.");
+  }
+
+  return { changeId, overwrite };
+};
+
+const resolveReviewOutput = (schubDir: string, changeId: string, output?: string) => {
+  if (output) {
+    return resolve(schubDir, output);
+  }
+  return join(schubDir, "changes", changeId, "REVIEW_ME.md");
+};
+
+export const runReviewCreate = (args: string[], startDir: string) => {
+  const options: ReviewCreateOptions = parseReviewCreateOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const trimmedId = options.changeId.trim();
+
+  if (!isValidChangeId(trimmedId)) {
+    throw new Error(
+      `Invalid change-id '${options.changeId}'. Use kebab-case or a C-prefixed id (e.g., C001_add-user-auth).`,
+    );
+  }
+
+  const changeId = normalizeChangeId(trimmedId);
+  const changeTitle = options.title?.trim() || readChangeSummary(schubDir, changeId).changeTitle;
+  const outputPath = resolveReviewOutput(schubDir, changeId, options.output);
+
+  if (existsSync(outputPath) && !options.overwrite) {
+    throw new Error(`Refusing to overwrite existing file: ${outputPath}`);
+  }
+
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("review-proposal", "review-me-template.md"),
+    BUNDLED_REVIEW_TEMPLATE_PATH,
+  );
+  const template = readFileSync(templatePath, "utf8");
+  const rendered = renderChangeTemplate(template, changeTitle || changeId, changeId);
+  writeFileSync(outputPath, rendered, "utf8");
+
+  process.stdout.write(`[OK] Wrote REVIEW_ME: ${outputPath}\n`);
+};
+
+export const runReviewComplete = (args: string[], startDir: string) => {
+  const options: ReviewCompleteOptions = parseReviewCompleteOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const summary = readChangeSummary(schubDir, options.changeId);
+  const reviewPath = join(summary.changeDir, "REVIEW_ME.md");
+
+  if (!existsSync(reviewPath)) {
+    throw new Error(`Review file not found: ${reviewPath}`);
+  }
+
+  const reviewContent = readFileSync(reviewPath, "utf8");
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("review-proposal", "q&a-template.md"),
+    BUNDLED_QNA_TEMPLATE_PATH,
+  );
+  const template = readFileSync(templatePath, "utf8");
+  const rendered = renderChangeTemplate(template, summary.changeTitle, summary.changeId).replace(
+    "{{REVIEW_CONTENT}}",
+    reviewContent,
+  );
+  const outputPath = join(summary.changeDir, "Q&A.md");
+
+  if (existsSync(outputPath) && !options.overwrite) {
+    throw new Error(`Refusing to overwrite existing file: ${outputPath}`);
+  }
+
+  writeFileSync(outputPath, rendered, "utf8");
+  unlinkSync(reviewPath);
+
+  process.stdout.write(`[OK] Wrote Q&A: ${outputPath}\n`);
+  process.stdout.write(`[NEXT] Ask the LLM to migrate the TODO block in ${outputPath} into the Q&A sections.\n`);
+};

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

@@ -0,0 +1,172 @@
+import { expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, 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 taskTemplatePath = join(cliDir, "templates", "create-tasks", "task-template.md");
+const decoder = new TextDecoder();
+
+const runTasksCreate = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "tasks", "create", ...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 createRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-tasks-create-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+  return { repoRoot, cwd };
+};
+
+const seedProposal = (schubRoot: string, changeId: string, status = "Accepted") => {
+  const changeDir = join(schubRoot, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(join(changeDir, "proposal.md"), `# Proposal - Seed\n**Status**: ${status}\n`, "utf8");
+};
+
+const writeExistingTask = (schubRoot: string, status: string, id: string, slug: string) => {
+  const tasksDir = join(schubRoot, "tasks", status);
+  mkdirSync(tasksDir, { recursive: true });
+  const taskPath = join(tasksDir, `${id}_${slug}.md`);
+  writeFileSync(taskPath, `# Task: ${id} ${slug}\n`, "utf8");
+  return taskPath;
+};
+
+test("tasks create scaffolds multiple task files", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli");
+  writeExistingTask(schubRoot, "backlog", "T003", "existing-task");
+
+  const { result, stdout } = runTasksCreate(cwd, [
+    "--change-id",
+    "C001_update-cli",
+    "--status",
+    "ready",
+    "--title",
+    "First Task",
+    "--title",
+    "Second: Task!",
+  ]);
+
+  expect(result.exitCode).toBe(0);
+
+  const firstPath = join(schubRoot, "tasks", "ready", "T004_first-task.md");
+  const secondPath = join(schubRoot, "tasks", "ready", "T005_second-task.md");
+
+  expect(existsSync(firstPath)).toBe(true);
+  expect(existsSync(secondPath)).toBe(true);
+
+  const firstContent = readFileSync(firstPath, "utf8");
+  const template = readFileSync(taskTemplatePath, "utf8");
+  const expectedFirst = template
+    .replace("{{TASK_ID}}", "T004")
+    .replace("{{TASK_TITLE}}", "First Task")
+    .replace("{{CHANGE_ID}}", "C001_update-cli");
+  const expectedSecond = template
+    .replace("{{TASK_ID}}", "T005")
+    .replace("{{TASK_TITLE}}", "Second: Task!")
+    .replace("{{CHANGE_ID}}", "C001_update-cli");
+
+  expect(firstContent).toBe(expectedFirst);
+  expect(readFileSync(secondPath, "utf8")).toBe(expectedSecond);
+
+  expect(stdout).toContain(`[OK] Wrote task: ${firstPath}`);
+  expect(stdout).toContain(`[OK] Wrote task: ${secondPath}`);
+});
+
+test("tasks create prefers local template overrides", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli");
+
+  const localTemplateDir = join(schubRoot, "templates", "create-tasks");
+  mkdirSync(localTemplateDir, { recursive: true });
+  const localTemplate = "# Local {{TASK_ID}} {{TASK_TITLE}}\nChange: {{CHANGE_ID}}\n";
+  writeFileSync(join(localTemplateDir, "task-template.md"), localTemplate, "utf8");
+
+  const { result } = runTasksCreate(cwd, [
+    "--change-id",
+    "C001_update-cli",
+    "--status",
+    "ready",
+    "--title",
+    "Local Task",
+  ]);
+
+  expect(result.exitCode).toBe(0);
+
+  const taskPath = join(schubRoot, "tasks", "ready", "T001_local-task.md");
+  const content = readFileSync(taskPath, "utf8");
+  const expected = localTemplate
+    .replace("{{TASK_ID}}", "T001")
+    .replace("{{TASK_TITLE}}", "Local Task")
+    .replace("{{CHANGE_ID}}", "C001_update-cli");
+
+  expect(content).toBe(expected);
+});
+
+test("tasks create rejects invalid status", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli");
+
+  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C001_update-cli", "--status", "bad status"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Invalid status");
+});
+
+test("tasks create rejects missing proposal", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  mkdirSync(join(schubRoot, "changes"), { recursive: true });
+
+  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C001_missing", "--title", "New Task"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Required change files missing");
+});
+
+test("tasks create rejects non-accepted proposals", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli", "Draft");
+
+  const { result, stderr } = runTasksCreate(cwd, ["--change-id", "C001_update-cli", "--title", "New Task"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Mark the proposal as Accepted");
+});
+
+test("tasks create rejects schub root flags", () => {
+  const { repoRoot, cwd } = createRepo();
+  const schubRoot = join(repoRoot, ".schub");
+  seedProposal(schubRoot, "C001_update-cli");
+
+  const { result, stderr } = runTasksCreate(cwd, [
+    "--change-id",
+    "C001_update-cli",
+    "--title",
+    "New Task",
+    "--schub-root",
+    "/tmp",
+  ]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("Unsupported option: --schub-root.");
+});

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");
+});