schub 0.1.2 → 0.1.4

package/src/features/tasks/worktree.ts

@@ -0,0 +1,48 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { resolveGitRoot } from "../../init";
+
+type TaskWorktreeOptions = {
+  repoRoot: string;
+  taskId: string;
+  worktreeRoot?: string;
+};
+
+const runGit = (gitRoot: string, args: string[]) => {
+  return spawnSync("git", args, {
+    cwd: gitRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+};
+
+export const createTaskWorktree = ({ repoRoot, taskId, worktreeRoot }: TaskWorktreeOptions) => {
+  const gitRoot = resolveGitRoot(repoRoot);
+  if (!gitRoot) {
+    return null;
+  }
+
+  const branchName = `task/${taskId}`;
+  const resolvedRoot = worktreeRoot ? resolve(gitRoot, worktreeRoot) : join(gitRoot, ".schub", "worktrees");
+  const worktreePath = join(resolvedRoot, taskId);
+
+  if (existsSync(worktreePath)) {
+    throw new Error(`Worktree path already exists: ${worktreePath}`);
+  }
+
+  const branchCheck = runGit(gitRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
+  if (branchCheck.status === 0) {
+    throw new Error(`Branch ${branchName} already exists.`);
+  }
+
+  mkdirSync(resolvedRoot, { recursive: true });
+
+  const worktreeResult = runGit(gitRoot, ["worktree", "add", "-b", branchName, worktreePath]);
+  if (worktreeResult.status !== 0) {
+    const message = worktreeResult.stderr?.trim();
+    throw new Error(message || "Failed to create worktree.");
+  }
+
+  return { worktreePath, branchName, gitRoot };
+};

package/src/frontmatter.ts

@@ -0,0 +1,115 @@
+export type FrontmatterValue = string | string[];
+export type FrontmatterData = Record<string, FrontmatterValue>;
+
+type FrontmatterReadResult = {
+  data: FrontmatterData;
+  body: string;
+};
+
+const FRONTMATTER_PATTERN = /^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/;
+
+const unquote = (value: string) => {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) {
+    return trimmed;
+  }
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+};
+
+const parseInlineList = (value: string) => {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+    return null;
+  }
+  const inner = trimmed.slice(1, -1).trim();
+  if (!inner) {
+    return [];
+  }
+  return inner
+    .split(",")
+    .map((item) => unquote(item))
+    .map((item) => item.trim())
+    .filter(Boolean);
+};
+
+const parseFrontmatterLines = (lines: string[]) => {
+  const data: FrontmatterData = {};
+  let activeKey: string | null = null;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    const keyMatch = trimmed.match(/^([a-z0-9_]+):\s*(.*)$/);
+    if (keyMatch) {
+      const key = keyMatch[1];
+      const rawValue = keyMatch[2].trim();
+      const inlineList = parseInlineList(rawValue);
+      if (inlineList) {
+        data[key] = inlineList;
+        activeKey = null;
+        continue;
+      }
+      if (!rawValue) {
+        data[key] = [];
+        activeKey = key;
+        continue;
+      }
+      if (rawValue === "[]") {
+        data[key] = [];
+        activeKey = null;
+        continue;
+      }
+      data[key] = unquote(rawValue);
+      activeKey = null;
+      continue;
+    }
+
+    const listMatch = trimmed.match(/^-+\s*(.+)$/);
+    if (listMatch && activeKey) {
+      const current = data[activeKey];
+      if (Array.isArray(current)) {
+        current.push(unquote(listMatch[1]).trim());
+      }
+    }
+  }
+
+  return data;
+};
+
+export const readFrontmatter = (content: string): FrontmatterReadResult => {
+  const match = content.match(FRONTMATTER_PATTERN);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const lines = match[1].split(/\r?\n/);
+  const data = parseFrontmatterLines(lines);
+  const body = content.slice(match[0].length);
+  return { data, body };
+};
+
+export const updateFrontmatterValue = (content: string, key: string, value: string) => {
+  const match = content.match(FRONTMATTER_PATTERN);
+  if (!match) {
+    throw new Error("Frontmatter block not found.");
+  }
+  const lines = match[1].split(/\r?\n/);
+  let found = false;
+  const updatedLines = lines.map((line) => {
+    const keyMatch = line.match(/^([a-z0-9_]+):/);
+    if (keyMatch?.[1] === key) {
+      found = true;
+      return `${key}: ${value}`;
+    }
+    return line;
+  });
+  if (!found) {
+    throw new Error(`Frontmatter field '${key}' not found.`);
+  }
+  return `---\n${updatedLines.join("\n")}\n---\n${content.slice(match[0].length)}`;
+};

package/src/index.test.ts

@@ -3,7 +3,9 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "bun";
 
-test("schub help lists tasks list", () => {
+const packageData = await Bun.file(new URL("../package.json", import.meta.url)).json();
+
+test("schub help lists top-level commands", () => {
   const testDir = dirname(fileURLToPath(import.meta.url));
   const cliDir = resolve(testDir, "..");
   const result = spawnSync({
@@ -13,11 +15,45 @@ test("schub help lists tasks list", () => {
 
   expect(result.exitCode).toBe(0);
   const stdout = new TextDecoder().decode(result.stdout ?? new Uint8Array());
-  expect(stdout).toContain("changes create");
-  expect(stdout).toContain("eject");
-  expect(stdout).toContain("init");
-  expect(stdout).toContain("tasks list");
-  expect(stdout).toContain("review complete");
+  expect(stdout).toContain("schub changes");
+  expect(stdout).toContain("schub tasks");
+  expect(stdout).toContain("schub roadmap");
+  expect(stdout).toContain("schub review");
+  expect(stdout).toContain("schub init");
+  expect(stdout).toContain("schub eject");
+  expect(stdout).toContain("schub ui");
+  expect(stdout).toContain("--version");
   expect(stdout).not.toContain("lint");
   expect(stdout).not.toContain("format");
 });
+
+test("schub version prints package version", () => {
+  const testDir = dirname(fileURLToPath(import.meta.url));
+  const cliDir = resolve(testDir, "..");
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "--version"],
+    cwd: cliDir,
+  });
+
+  expect(result.exitCode).toBe(0);
+  const stdout = new TextDecoder().decode(result.stdout ?? new Uint8Array());
+  expect(stdout.trim()).toBe(packageData.version);
+});
+
+test("schub changes help is scoped to changes commands", () => {
+  const testDir = dirname(fileURLToPath(import.meta.url));
+  const cliDir = resolve(testDir, "..");
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "changes", "--help"],
+    cwd: cliDir,
+  });
+
+  expect(result.exitCode).toBe(0);
+  const stdout = new TextDecoder().decode(result.stdout ?? new Uint8Array());
+  expect(stdout).toContain("create");
+  expect(stdout).toContain("status");
+  expect(stdout).toContain("archive");
+  expect(stdout).toContain("list");
+  expect(stdout).not.toContain("project create");
+  expect(stdout).not.toContain("tasks list");
+});

package/src/index.ts

@@ -1,131 +1,248 @@
 #!/usr/bin/env bun
-import { render } from "ink";
-import React from "react";
-import App from "./App";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 import { runAdrCreate } from "./commands/adr";
-import { runChangesCreate, runChangesStatus } from "./commands/changes";
+import { runChangesArchive, runChangesCreate, runChangesList, runChangesStatus } from "./commands/changes";
 import { runCookbookCreate } from "./commands/cookbook";
 import { runEject } from "./commands/eject";
 import { runInit } from "./commands/init";
 import { runProjectCreate } from "./commands/project";
 import { runReviewComplete, runReviewCreate } from "./commands/review";
-import { runTasksCreate, runTasksList } from "./commands/tasks";
+import { runRoadmapAdd, runRoadmapList, runRoadmapPropose } from "./commands/roadmap";
+import { runTasksCreate, runTasksImplement, runTasksList, runTasksUpdate } from "./commands/tasks";
 import { findSchubRoot } from "./features/tasks";
-import { applyTerminalPrelude, applyTerminalReset } from "./terminal";
+import { runTui } from "./tui";
 
-const HELP_TEXT = `schub [command]
-
-Commands:
-  changes create    Create a change proposal
-  changes status    Update change proposal status
-  project create    Create project docs
-  tasks create      Create task files for a change
-  tasks list        List tasks
-  review create     Create REVIEW_ME for a change
-  review complete   Create Q&A from REVIEW_ME
-  adr create        Create an ADR for a change
-  cookbook create   Create a cookbook for a change
-  init              Initialize .schub and install Codex skills
-  eject             Copy bundled skills and templates into .schub
-  ui                Launch the interactive dashboard
-`;
+const packageData = await Bun.file(new URL("../package.json", import.meta.url)).json();
 
 const getStartDir = () => process.env.SCHUB_CWD ?? process.cwd();
 
 const resolveSchubDir = () => findSchubRoot(getStartDir());
 
-const printHelp = (exitCode = 0) => {
-  process.stdout.write(`${HELP_TEXT}\n`);
-  process.exitCode = exitCode;
-};
-
-const registerTerminalReset = () => {
-  process.once("exit", () => {
-    applyTerminalReset();
-  });
-};
-
-const runUi = () => {
-  applyTerminalPrelude();
-  registerTerminalReset();
-  render(React.createElement(App));
-};
-
 const runCommand = async () => {
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    runUi();
-    return;
-  }
-
-  if (args.includes("--help") || args.includes("-h")) {
-    printHelp();
+  const rawArgs = process.argv.slice(2);
+  if (rawArgs.length === 0) {
+    runTui();
     return;
   }
 
-  const [primary, secondary, ...rest] = args;
-
-  switch (primary) {
-    case "changes":
-      if (secondary === "create") {
-        runChangesCreate(rest, getStartDir());
-        return;
-      }
-      if (secondary === "status") {
-        runChangesStatus(rest, getStartDir());
-        return;
-      }
-      break;
-    case "project":
-      if (secondary === "create") {
-        runProjectCreate(rest, getStartDir());
-        return;
-      }
-      break;
-    case "tasks":
-      if (secondary === "list") {
-        runTasksList(resolveSchubDir(), rest);
-        return;
-      }
-      if (secondary === "create") {
-        runTasksCreate(rest, getStartDir());
-        return;
-      }
-      break;
-    case "review":
-      if (secondary === "create") {
-        runReviewCreate(rest, getStartDir());
-        return;
-      }
-      if (secondary === "complete") {
-        runReviewComplete(rest, getStartDir());
-        return;
-      }
-      break;
-    case "adr":
-      if (secondary === "create") {
-        runAdrCreate(rest, getStartDir());
-        return;
-      }
-      break;
-    case "cookbook":
-      if (secondary === "create") {
-        runCookbookCreate(rest, getStartDir());
-        return;
-      }
-      break;
-    case "eject":
-      runEject(args.slice(1), getStartDir());
-      return;
-    case "init":
-      await runInit(args.slice(1), getStartDir());
-      return;
-    case "ui":
-      runUi();
-      return;
-  }
+  const startDir = getStartDir();
+  const cli = yargs(hideBin(process.argv))
+    .scriptName("schub")
+    .usage("schub [command]")
+    .command(
+      "changes",
+      "Change proposal commands",
+      (command) =>
+        command
+          .command(
+            "create [args..]",
+            "Create a change proposal",
+            () => {},
+            () => {
+              runChangesCreate(rawArgs.slice(2), startDir);
+            },
+          )
+          .command(
+            "status [args..]",
+            "Update change proposal status",
+            () => {},
+            () => {
+              runChangesStatus(rawArgs.slice(2), startDir);
+            },
+          )
+          .command(
+            "archive [args..]",
+            "Archive a change proposal",
+            () => {},
+            () => {
+              runChangesArchive(rawArgs.slice(2), startDir);
+            },
+          )
+          .command(
+            "list [args..]",
+            "List change proposals",
+            () => {},
+            () => {
+              runChangesList(rawArgs.slice(2), startDir);
+            },
+          )
+          .demandCommand(1, "Provide a changes command."),
+      () => {},
+    )
+    .command(
+      "project",
+      "Project documentation commands",
+      (command) =>
+        command
+          .command(
+            "create [args..]",
+            "Create project docs",
+            () => {},
+            () => {
+              runProjectCreate(rawArgs.slice(2), startDir);
+            },
+          )
+          .demandCommand(1, "Provide a project command."),
+      () => {},
+    )
+    .command(
+      "tasks",
+      "Task commands",
+      (command) =>
+        command
+          .command(
+            "create [args..]",
+            "Create task files for a change",
+            () => {},
+            () => {
+              runTasksCreate(rawArgs.slice(2), startDir);
+            },
+          )
+          .command(
+            "list [args..]",
+            "List tasks",
+            () => {},
+            () => {
+              runTasksList(resolveSchubDir(), rawArgs.slice(2));
+            },
+          )
+          .command(
+            "update [args..]",
+            "Update backlog task status",
+            () => {},
+            () => {
+              runTasksUpdate(resolveSchubDir(), rawArgs.slice(2));
+            },
+          )
+          .command(
+            "implement [args..]",
+            "Assign a task for implementation",
+            () => {},
+            () => {
+              runTasksImplement(resolveSchubDir(), rawArgs.slice(2));
+            },
+          )
+          .demandCommand(1, "Provide a tasks command."),
+      () => {},
+    )
+    .command(
+      "roadmap",
+      "Roadmap commands",
+      (command) =>
+        command
+          .command(
+            "add [args..]",
+            "Add a roadmap item",
+            () => {},
+            () => {
+              runRoadmapAdd(startDir, rawArgs.slice(2));
+            },
+          )
+          .command(
+            "list [args..]",
+            "List roadmap items",
+            () => {},
+            () => {
+              runRoadmapList(startDir, rawArgs.slice(2));
+            },
+          )
+          .command(
+            "propose [args..]",
+            "Create proposal from a roadmap item",
+            () => {},
+            () => {
+              runRoadmapPropose(startDir, rawArgs.slice(2));
+            },
+          )
+          .demandCommand(1, "Provide a roadmap command."),
+      () => {},
+    )
+    .command(
+      "review",
+      "Review commands",
+      (command) =>
+        command
+          .command(
+            "create [args..]",
+            "Create REVIEW_ME for a change",
+            () => {},
+            () => {
+              runReviewCreate(rawArgs.slice(2), startDir);
+            },
+          )
+          .command(
+            "complete [args..]",
+            "Create Q&A from REVIEW_ME",
+            () => {},
+            () => {
+              runReviewComplete(rawArgs.slice(2), startDir);
+            },
+          )
+          .demandCommand(1, "Provide a review command."),
+      () => {},
+    )
+    .command(
+      "adr",
+      "ADR commands",
+      (command) =>
+        command
+          .command(
+            "create [args..]",
+            "Create an ADR for a change",
+            () => {},
+            () => {
+              runAdrCreate(rawArgs.slice(2), startDir);
+            },
+          )
+          .demandCommand(1, "Provide an adr command."),
+      () => {},
+    )
+    .command(
+      "cookbook",
+      "Cookbook commands",
+      (command) =>
+        command
+          .command(
+            "create [args..]",
+            "Create a cookbook for a change",
+            () => {},
+            () => {
+              runCookbookCreate(rawArgs.slice(2), startDir);
+            },
+          )
+          .demandCommand(1, "Provide a cookbook command."),
+      () => {},
+    )
+    .command(
+      "init [args..]",
+      "Initialize .schub and install Codex skills",
+      () => {},
+      async () => {
+        await runInit(rawArgs.slice(1), startDir);
+      },
+    )
+    .command(
+      "eject [args..]",
+      "Copy bundled skills and templates into .schub",
+      () => {},
+      () => {
+        runEject(rawArgs.slice(1), startDir);
+      },
+    )
+    .command(
+      "ui",
+      "Launch the interactive dashboard",
+      () => {},
+      () => {
+        runTui();
+      },
+    )
+    .help()
+    .version(packageData.version)
+    .strictCommands();
 
-  printHelp(1);
+  await cli.parseAsync();
 };
 
 runCommand().catch((error) => {

package/src/opencode.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from "bun:test";
+import { buildImplementCommand, buildReviewCommand, launchOpencodeImplement } from "./opencode";
+
+type SpawnCall = {
+  command: string;
+  args: string[];
+  options: { stdio: "ignore"; detached: true; env?: NodeJS.ProcessEnv; cwd?: string };
+};
+
+const repoRoot = "/repo/schub";
+
+const createSpawnRecorder = () => {
+  const calls: SpawnCall[] = [];
+
+  const spawner = (
+    command: string,
+    args: readonly string[],
+    options: { stdio: "ignore"; detached: true; env?: NodeJS.ProcessEnv; cwd?: string },
+  ) => {
+    calls.push({ command, args: [...args], options });
+    return { unref: () => {} };
+  };
+
+  return { calls, spawner };
+};
+
+test("buildReviewCommand uses opencode run review with title", () => {
+  expect(buildReviewCommand("C0001", repoRoot)).toEqual({
+    command: "opencode",
+    args: ["run", "review", "C0001", "--title", "(schub) Review C0001"],
+  });
+});
+
+test("buildImplementCommand uses opencode run implement with title", () => {
+  expect(buildImplementCommand("T0001", repoRoot, "Task Title")).toEqual({
+    command: "opencode",
+    args: ["run", "implement", "T0001", "--title", "(schub) Implement T0001 Task Title"],
+  });
+});
+
+test("launchOpencodeImplement spawns implement command", () => {
+  const { calls, spawner } = createSpawnRecorder();
+
+  launchOpencodeImplement("T0001", repoRoot, "Task Title", undefined, spawner);
+
+  expect(calls).toEqual([
+    {
+      command: "opencode",
+      args: ["run", "implement", "T0001", "--title", "(schub) Implement T0001 Task Title"],
+      options: { stdio: "ignore", detached: true },
+    },
+  ]);
+});