schub 0.1.3 → 0.1.4

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

@@ -0,0 +1,92 @@
+import { expect, test } from "bun:test";
+import { existsSync, 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 runTasksUpdate = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "tasks", "update", ...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-update-"));
+  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) => {
+  const filePath = join(tasksRoot, status, `${id}_${slug}.md`);
+  writeFileSync(filePath, `# Task: ${id} ${slug}\n`, "utf8");
+  return filePath;
+};
+
+test("tasks update moves multiple backlog tasks to ready", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(tasksRoot, "backlog", "T0001", "first-task");
+  writeTask(tasksRoot, "backlog", "T0002", "second-task");
+
+  const { result, stdout } = runTasksUpdate(cwd, ["--status", "ready", "--id", "T0001", "--id", "T0002"]);
+
+  expect(result.exitCode).toBe(0);
+
+  const readyRoot = join(tasksRoot, "ready");
+  const movedFirst = join(readyRoot, "T0001_first-task.md");
+  const movedSecond = join(readyRoot, "T0002_second-task.md");
+
+  expect(existsSync(movedFirst)).toBe(true);
+  expect(existsSync(movedSecond)).toBe(true);
+  expect(existsSync(join(tasksRoot, "backlog", "T0001_first-task.md"))).toBe(false);
+  expect(existsSync(join(tasksRoot, "backlog", "T0002_second-task.md"))).toBe(false);
+
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  expect(lines).toHaveLength(2);
+  expect(lines[0]).toContain("[OK]");
+  expect(lines[0]).toContain("T0001");
+  expect(lines[0]).toContain("ready");
+  expect(lines[1]).toContain("[OK]");
+  expect(lines[1]).toContain("T0002");
+  expect(lines[1]).toContain("ready");
+});
+
+test("tasks update moves backlog task to archived", () => {
+  const { cwd, tasksRoot } = createTaskRepo();
+  writeTask(tasksRoot, "backlog", "T0003", "archive-task");
+
+  const { result, stdout } = runTasksUpdate(cwd, ["--status", "archived", "--id", "T0003"]);
+
+  expect(result.exitCode).toBe(0);
+
+  const archivedRoot = join(tasksRoot, "archived");
+  const archivedTask = join(archivedRoot, "T0003_archive-task.md");
+
+  expect(existsSync(archivedTask)).toBe(true);
+  expect(existsSync(join(tasksRoot, "backlog", "T0003_archive-task.md"))).toBe(false);
+  expect(stdout).toContain("[OK]");
+  expect(stdout).toContain("T0003");
+  expect(stdout).toContain("archived");
+});

package/src/commands/tasks.ts

@@ -1,5 +1,5 @@
 import { resolveChangeRoot } from "../changes";
-import { createTask, listTasks, TASK_STATUSES, type TaskStatus } from "../features/tasks";
+import { createTask, listTasks, TASK_STATUSES, type TaskStatus, updateTaskStatuses } from "../features/tasks";
 
 const parseStatusFilter = (value: string | undefined) => {
   if (!value) {
@@ -138,6 +138,88 @@ const parseTaskCreateOptions = (args: string[]) => {
   return options;
 };
 
+const BACKLOG_UPDATE_STATUSES = ["ready", "archived"] as const;
+
+type BacklogUpdateStatus = (typeof BACKLOG_UPDATE_STATUSES)[number];
+
+type TaskUpdateOptions = {
+  taskIds: string[];
+  status: BacklogUpdateStatus;
+};
+
+const parseTaskUpdateOptions = (args: string[]) => {
+  let statusValue: string | undefined;
+  const taskIds: 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 === "--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;
+    }
+    if (arg === "--id") {
+      const taskId = args[index + 1];
+      if (!taskId) {
+        throw new Error("Missing value for --id.");
+      }
+      taskIds.push(taskId);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--id=")) {
+      taskIds.push(arg.slice("--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 (!statusValue) {
+    throw new Error("Provide --status.");
+  }
+
+  const normalizedStatus = statusValue.trim().toLowerCase();
+  if (!BACKLOG_UPDATE_STATUSES.includes(normalizedStatus as BacklogUpdateStatus)) {
+    throw new Error(`Invalid status '${statusValue}'. Use ready or archived.`);
+  }
+
+  const normalizedIds = taskIds.map((id) => id.trim()).filter(Boolean);
+  if (normalizedIds.length === 0) {
+    throw new Error("Provide at least one --id.");
+  }
+
+  const options: TaskUpdateOptions = {
+    taskIds: normalizedIds,
+    status: normalizedStatus as BacklogUpdateStatus,
+  };
+  return options;
+};
+
 export const runTasksList = (schubDir: string | null, args: string[]) => {
   if (!schubDir) {
     throw new Error("No .schub directory found.");
@@ -161,6 +243,19 @@ export const runTasksList = (schubDir: string | null, args: string[]) => {
   process.stdout.write(`${lines.join("\n")}\n`);
 };
 
+export const runTasksUpdate = (schubDir: string | null, args: string[]) => {
+  if (!schubDir) {
+    throw new Error("No .schub directory found.");
+  }
+
+  const options = parseTaskUpdateOptions(args);
+  const updated = updateTaskStatuses(schubDir, options.taskIds, options.status);
+
+  for (const task of updated) {
+    process.stdout.write(`[OK] Updated task ${task.id}: backlog -> ${task.status}\n`);
+  }
+};
+
 export const runTasksCreate = (args: string[], startDir: string) => {
   const options = parseTaskCreateOptions(args);
   const schubDir = resolveChangeRoot(startDir);
@@ -170,3 +265,5 @@ export const runTasksCreate = (args: string[], startDir: string) => {
     process.stdout.write(`[OK] Wrote task: ${taskPath}\n`);
   }
 };
+
+export { runTasksImplement } from "./tasks-implement";

package/src/features/roadmap/index.ts

@@ -0,0 +1,230 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createChange, listChangeOverview } from "../../changes";
+import { resolveTemplatePath } from "../../templates";
+
+export type RoadmapItem = {
+  index: number;
+  lineIndex: number;
+  story: string;
+  proposalRef: string | null;
+  proposalId?: string;
+};
+
+type RoadmapFile = {
+  path: string;
+  lines: string[];
+  items: RoadmapItem[];
+};
+
+type RoadmapWriteResult = {
+  path: string;
+  created: boolean;
+};
+
+const ROADMAP_PLACEHOLDER = "<PROPOSAL_REF>";
+const ROADMAP_BULLET_PATTERN = /^\s*-\s+(.*)$/;
+const ROADMAP_REF_PATTERN = /^\*\*(.+?)\*\*:\s*(.*)$/;
+const CHANGE_PREFIX_PATTERN = /^([Cc])(\d+)(?:_.+)?$/;
+
+const BUNDLED_ROADMAP_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../../templates/create-roadmap/roadmap.md", import.meta.url),
+);
+
+const normalizeProposalRef = (value: string) => {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === ROADMAP_PLACEHOLDER) {
+    return null;
+  }
+  const match = trimmed.match(CHANGE_PREFIX_PATTERN);
+  if (!match) {
+    return null;
+  }
+  return `C${match[2]}`;
+};
+
+const normalizeChangePrefix = (value: string) => {
+  const match = value.trim().match(CHANGE_PREFIX_PATTERN);
+  if (!match) {
+    throw new Error(`Invalid proposal prefix '${value}'. Use C<number>.`);
+  }
+  return `C${match[2]}`;
+};
+
+const ensureStoryPunctuation = (story: string) => {
+  if (/[.!?]$/.test(story)) {
+    return story;
+  }
+  return `${story}.`;
+};
+
+const parseRoadmapLine = (line: string) => {
+  const bulletMatch = line.match(ROADMAP_BULLET_PATTERN);
+  if (!bulletMatch) {
+    return null;
+  }
+
+  const content = bulletMatch[1].trim();
+  const refMatch = content.match(ROADMAP_REF_PATTERN);
+  if (refMatch) {
+    const proposalRef = normalizeProposalRef(refMatch[1]);
+    return { proposalRef, story: refMatch[2].trim() };
+  }
+
+  return { proposalRef: null, story: content };
+};
+
+const buildChangePrefixMap = (schubDir: string) => {
+  const changes = listChangeOverview(schubDir);
+  const map = new Map<string, string>();
+
+  for (const change of changes) {
+    const prefixMatch = change.id.match(/^([Cc]\d+)_/);
+    if (!prefixMatch) {
+      continue;
+    }
+    const prefix = prefixMatch[1].toUpperCase();
+    const existing = map.get(prefix);
+    if (existing) {
+      throw new Error(`Duplicate change prefix '${prefix}' found for ${existing} and ${change.id}.`);
+    }
+    map.set(prefix, change.id);
+  }
+
+  return map;
+};
+
+const getRoadmapPath = (schubDir: string) => join(schubDir, "roadmap.md");
+
+const readRoadmapFile = (schubDir: string): RoadmapFile => {
+  const roadmapPath = getRoadmapPath(schubDir);
+  if (!existsSync(roadmapPath)) {
+    throw new Error(`Roadmap file not found at ${roadmapPath}. Run schub init first.`);
+  }
+  const content = readFileSync(roadmapPath, "utf8");
+  const lines = content.split(/\r?\n/);
+  const items: RoadmapItem[] = [];
+  let index = 1;
+
+  for (const [lineIndex, line] of lines.entries()) {
+    const parsed = parseRoadmapLine(line);
+    if (!parsed) {
+      continue;
+    }
+    items.push({
+      index,
+      lineIndex,
+      story: parsed.story,
+      proposalRef: parsed.proposalRef,
+    });
+    index += 1;
+  }
+
+  const changeMap = buildChangePrefixMap(schubDir);
+  const enriched = items.map((item) => {
+    if (!item.proposalRef) {
+      return item;
+    }
+    const proposalId = changeMap.get(item.proposalRef) ?? undefined;
+    return { ...item, proposalId };
+  });
+
+  return { path: roadmapPath, lines, items: enriched };
+};
+
+const writeRoadmapLines = (roadmapPath: string, lines: string[]) => {
+  writeFileSync(roadmapPath, lines.join("\n"), "utf8");
+};
+
+const appendRoadmapLine = (lines: string[], line: string) => {
+  const updated = [...lines];
+  const insertIndex = updated.length > 0 && updated[updated.length - 1] === "" ? updated.length - 1 : updated.length;
+  updated.splice(insertIndex, 0, line);
+  if (updated[updated.length - 1] !== "") {
+    updated.push("");
+  }
+  return updated;
+};
+
+export const listRoadmapItems = (schubDir: string) => {
+  const roadmap = readRoadmapFile(schubDir);
+  return roadmap.items;
+};
+
+export const addRoadmapItem = (schubDir: string, story: string) => {
+  const trimmed = story.trim();
+  if (!trimmed) {
+    throw new Error("Provide a roadmap story.");
+  }
+
+  const roadmap = readRoadmapFile(schubDir);
+  const normalizedStory = ensureStoryPunctuation(trimmed);
+  const line = `- **${ROADMAP_PLACEHOLDER}**: ${normalizedStory}`;
+  const updated = appendRoadmapLine(roadmap.lines, line);
+  writeRoadmapLines(roadmap.path, updated);
+};
+
+export const updateRoadmapItemProposal = (schubDir: string, index: number, proposalRef: string) => {
+  const roadmap = readRoadmapFile(schubDir);
+  const target = roadmap.items.find((item) => item.index === index);
+  if (!target) {
+    throw new Error(`No roadmap item found for index ${index}.`);
+  }
+  if (target.proposalRef) {
+    throw new Error(`Roadmap item ${index} already has a proposal ref (${target.proposalRef}).`);
+  }
+
+  const normalizedRef = normalizeChangePrefix(proposalRef);
+  const duplicate = roadmap.items.find((item) => item.proposalRef === normalizedRef);
+  if (duplicate) {
+    throw new Error(`Roadmap item ${duplicate.index} already references ${normalizedRef}.`);
+  }
+
+  roadmap.lines[target.lineIndex] = `- **${normalizedRef}**: ${target.story}`;
+  writeRoadmapLines(roadmap.path, roadmap.lines);
+};
+
+export const ensureRoadmapFile = (schubDir: string): RoadmapWriteResult => {
+  const roadmapPath = getRoadmapPath(schubDir);
+  if (existsSync(roadmapPath)) {
+    return { path: roadmapPath, created: false };
+  }
+
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("create-roadmap", "roadmap.md"),
+    BUNDLED_ROADMAP_TEMPLATE_PATH,
+  );
+  const template = readFileSync(templatePath, "utf8");
+  writeFileSync(roadmapPath, template, "utf8");
+  return { path: roadmapPath, created: true };
+};
+
+export const proposeRoadmapItem = (schubDir: string, index: number) => {
+  const roadmap = readRoadmapFile(schubDir);
+  const target = roadmap.items.find((item) => item.index === index);
+  if (!target) {
+    throw new Error(`No roadmap item found for index ${index}.`);
+  }
+  if (target.proposalRef) {
+    throw new Error(`Roadmap item ${index} already has a proposal ref (${target.proposalRef}).`);
+  }
+  if (!target.story.trim()) {
+    throw new Error(`Roadmap item ${index} has no story text.`);
+  }
+
+  const proposalPath = createChange(schubDir, {
+    title: target.story,
+    input: target.story,
+  });
+  const changeId = basename(dirname(proposalPath));
+  const prefixMatch = changeId.match(/^([Cc]\d+)_/);
+  if (!prefixMatch) {
+    throw new Error(`Unable to derive prefix from change id '${changeId}'.`);
+  }
+  const proposalRef = prefixMatch[1].toUpperCase();
+  updateRoadmapItemProposal(schubDir, index, proposalRef);
+
+  return { proposalPath, changeId, proposalRef };
+};

package/src/features/roadmap/roadmap.test.ts

@@ -0,0 +1,77 @@
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { addRoadmapItem, ensureRoadmapFile, listRoadmapItems, updateRoadmapItemProposal } from "./index";
+
+const createRoadmapRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-roadmap-"));
+  const schubDir = join(base, ".schub");
+  mkdirSync(schubDir, { recursive: true });
+  const roadmapPath = join(schubDir, "roadmap.md");
+  const roadmap = [
+    "---",
+    'title: "Roadmap"',
+    "---",
+    "## Roadmap",
+    "",
+    "- **<PROPOSAL_REF>**: As a user, I want to sign in.",
+    "- **C0001**: As an admin, I want to manage accounts.",
+    "",
+  ].join("\n");
+  writeFileSync(roadmapPath, roadmap, "utf8");
+  return { schubDir, roadmapPath };
+};
+
+const seedProposal = (schubDir: string, changeId: string) => {
+  const changeDir = join(schubDir, "changes", changeId);
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(join(changeDir, "proposal.md"), "---\nstatus: Draft\n---\n# Proposal\n", "utf8");
+};
+
+test("listRoadmapItems parses items with proposal refs", () => {
+  const { schubDir } = createRoadmapRepo();
+  const items = listRoadmapItems(schubDir);
+
+  expect(items).toHaveLength(2);
+  expect(items[0]).toMatchObject({ index: 1, proposalRef: null, story: "As a user, I want to sign in." });
+  expect(items[1]).toMatchObject({ index: 2, proposalRef: "C0001", story: "As an admin, I want to manage accounts." });
+});
+
+test("addRoadmapItem appends a placeholder entry", () => {
+  const { schubDir, roadmapPath } = createRoadmapRepo();
+  addRoadmapItem(schubDir, "As a guest, I want to browse.");
+
+  const content = readFileSync(roadmapPath, "utf8");
+  expect(content).toContain("- **<PROPOSAL_REF>**: As a guest, I want to browse.");
+});
+
+test("updateRoadmapItemProposal replaces placeholder ref", () => {
+  const { schubDir, roadmapPath } = createRoadmapRepo();
+  updateRoadmapItemProposal(schubDir, 1, "C0002");
+
+  const content = readFileSync(roadmapPath, "utf8");
+  expect(content).toContain("- **C0002**: As a user, I want to sign in.");
+});
+
+test("ensureRoadmapFile writes the bundled template", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-roadmap-template-"));
+  const schubDir = join(base, ".schub");
+  mkdirSync(schubDir, { recursive: true });
+
+  const templatePath = fileURLToPath(new URL("../../../templates/create-roadmap/roadmap.md", import.meta.url));
+  const template = readFileSync(templatePath, "utf8");
+  const result = ensureRoadmapFile(schubDir);
+
+  const content = readFileSync(result.path, "utf8");
+  expect(result.created).toBe(true);
+  expect(content).toBe(template);
+});
+
+test("listRoadmapItems throws when proposal prefixes are duplicated", () => {
+  const { schubDir } = createRoadmapRepo();
+  seedProposal(schubDir, "C0001_first-change");
+  seedProposal(schubDir, "C0001_second-change");
+
+  expect(() => listRoadmapItems(schubDir)).toThrow("Duplicate change prefix");
+});

package/src/features/tasks/constants.ts

@@ -10,6 +10,7 @@ export type TaskInfo = {
   changeId?: string;
   checklistRemaining?: number;
   checklistTotal?: number;
+  blockedReason?: string;
 };
 
 export type TaskDependency = TaskInfo & {

package/src/features/tasks/create.ts

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { readFrontmatter } from "../../frontmatter";
 import { resolveTemplatePath } from "../../templates";
 
 const BUNDLED_TASK_TEMPLATE_PATH = fileURLToPath(
@@ -29,13 +30,13 @@ export const createTask = (
   const titles = options.titles.map((t) => t.trim()).filter(Boolean);
 
   // Validate change ID format (simple check)
-  if (!/^(?:[Cc]\d{4}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/.test(changeId)) {
-    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C0001_add-user-auth).`);
+  if (!/^(?:[Cc]\d+_)?[a-z0-9]+(?:-[a-z0-9]+)*$/.test(changeId)) {
+    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C1_add-user-auth).`);
   }
 
   // Normalize change ID (ensure C prefix if it matches pattern)
   let normalizedChangeId = changeId;
-  const match = changeId.match(/^([Cc])(\d{4})_(.+)$/);
+  const match = changeId.match(/^([Cc])(\d+)_(.+)$/);
   if (match) {
     normalizedChangeId = `C${match[2]}_${match[3]}`;
   }
@@ -60,12 +61,13 @@ export const createTask = (
   }
 
   const content = readFileSync(proposalPath, "utf8");
-  const statusMatch = content.match(/^\*\*Status\*\*:\s*(.+)$/im);
-  const proposalStatus = statusMatch?.[1]?.trim();
+  const { data } = readFrontmatter(content);
+  const proposalStatusValue = data.status;
+  const proposalStatus = typeof proposalStatusValue === "string" ? proposalStatusValue.trim() : "";
 
   if (!proposalStatus) {
     throw new Error(
-      `Proposal status not found in ${proposalPath}.\nAdd a '**Status**: Accepted' line before scaffolding tasks.`,
+      `Proposal status not found in ${proposalPath}.\nAdd a 'status' field in frontmatter before scaffolding tasks.`,
     );
   }
   if (proposalStatus.toLowerCase() !== "accepted") {
@@ -86,7 +88,7 @@ export const createTask = (
         if (entry.isDirectory()) {
           scan(join(dir, entry.name));
         } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          const m = entry.name.match(/(?:^|-)T(\d{4})(?:_[^.]+)?\.md$/);
+          const m = entry.name.match(/(?:^|-)T(\d+)(?:_[^.]+)?\.md$/);
           if (m) existingNumbers.add(Number.parseInt(m[1], 10));
         }
       }