schub 0.1.0 → 0.1.2

package/src/index.ts

@@ -1,391 +1,44 @@
 #!/usr/bin/env bun
-import { dirname } from "node:path";
-import { spawnSync } from "bun";
 import { render } from "ink";
 import React from "react";
 import App from "./App";
-import { createChange, resolveChangeRoot } from "./changes";
-import { createTask, findSchubRoot, listTasks, TASK_STATUSES, type TaskStatus } from "./features/tasks";
-import { createProject } from "./project";
+import { runAdrCreate } from "./commands/adr";
+import { runChangesCreate, 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 { findSchubRoot } from "./features/tasks";
 import { applyTerminalPrelude, applyTerminalReset } from "./terminal";
 
 const HELP_TEXT = `schub [command]
 
 Commands:
-  changes create   Create a change proposal
-  project create   Create project docs
-  tasks create     Create task files for a change
-  tasks list       List tasks
-  lint              Run Biome lint checks
-  format            Format files with Biome
+  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 getStartDir = (): string => process.env.SCHUB_CWD ?? process.cwd();
+const getStartDir = () => process.env.SCHUB_CWD ?? process.cwd();
 
-const getWorkspaceRoot = (): string => {
-  const schubDir = findSchubRoot(getStartDir());
-  return schubDir ? dirname(schubDir) : getStartDir();
-};
-
-const resolveSchubDir = (): string | null => findSchubRoot(getStartDir());
+const resolveSchubDir = () => findSchubRoot(getStartDir());
 
-const printHelp = (exitCode = 0): void => {
+const printHelp = (exitCode = 0) => {
   process.stdout.write(`${HELP_TEXT}\n`);
   process.exitCode = exitCode;
 };
 
-const parseStatusFilter = (value: string | undefined): TaskStatus[] => {
-  if (!value) {
-    return [...TASK_STATUSES];
-  }
-
-  const normalized = value
-    .split(",")
-    .map((status) => status.trim().toLowerCase())
-    .filter(Boolean);
-
-  const allowed = new Set(TASK_STATUSES);
-  const invalid = normalized.filter((status) => !allowed.has(status as TaskStatus));
-  if (invalid.length > 0) {
-    throw new Error(`Unknown status filter: ${invalid.join(", ")}`);
-  }
-
-  return normalized as TaskStatus[];
-};
-
-type TaskListOptions = {
-  statuses: TaskStatus[];
-  json: boolean;
-};
-
-const parseTaskListOptions = (args: string[]): TaskListOptions => {
-  let statusValue: string | undefined;
-  let json = false;
-  const unknown: string[] = [];
-
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--json") {
-      json = true;
-      continue;
-    }
-    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;
-    }
-    unknown.push(arg);
-  }
-
-  if (unknown.length > 0) {
-    throw new Error(`Unknown option(s): ${unknown.join(", ")}`);
-  }
-
-  return { statuses: parseStatusFilter(statusValue), json };
-};
-
-type ChangeCreateOptions = {
-  changeId?: string;
-  title?: string;
-  input?: string;
-  overwrite: boolean;
-};
-
-type ProjectCreateOptions = {
-  repoRoot?: string;
-  projectName?: string;
-  overwrite: boolean;
-};
-
-const parseChangeCreateOptions = (args: string[]) => {
-  let changeId: string | undefined;
-  let title: string | undefined;
-  let input: 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 === "--input") {
-      input = args[index + 1];
-      if (input === undefined) {
-        throw new Error("Missing value for --input.");
-      }
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--input=")) {
-      input = arg.slice("--input=".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(", ")}`);
-  }
-
-  const options: ChangeCreateOptions = { changeId, title, input, overwrite };
-  return options;
-};
-
-const parseProjectCreateOptions = (args: string[]) => {
-  let repoRoot: string | undefined;
-  let projectName: 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 === "--repo-root") {
-      repoRoot = args[index + 1];
-      if (repoRoot === undefined) {
-        throw new Error("Missing value for --repo-root.");
-      }
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--repo-root=")) {
-      repoRoot = arg.slice("--repo-root=".length);
-      continue;
-    }
-    if (arg === "--project-name") {
-      projectName = args[index + 1];
-      if (projectName === undefined) {
-        throw new Error("Missing value for --project-name.");
-      }
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--project-name=")) {
-      projectName = arg.slice("--project-name=".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(", ")}`);
-  }
-
-  return { repoRoot, projectName, overwrite };
-};
-
-type TaskCreateOptions = {
-  changeId: string;
-  status?: string;
-  titles: string[];
-  overwrite: boolean;
-};
-
-const parseTaskCreateOptions = (args: string[]) => {
-  let changeId: string | undefined;
-  let status: string | undefined;
-  let overwrite = false;
-  const titles: 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 === "--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 === "--status") {
-      status = args[index + 1];
-      if (status === undefined) {
-        throw new Error("Missing value for --status.");
-      }
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--status=")) {
-      status = arg.slice("--status=".length);
-      continue;
-    }
-    if (arg === "--title") {
-      const title = args[index + 1];
-      if (title === undefined) {
-        throw new Error("Missing value for --title.");
-      }
-      titles.push(title);
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--title=")) {
-      titles.push(arg.slice("--title=".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.");
-  }
-
-  const options: TaskCreateOptions = { changeId, status, titles, overwrite };
-  return options;
-};
-
-const runTasksList = (args: string[]): void => {
-  const schubDir = resolveSchubDir();
-  if (!schubDir) {
-    throw new Error("No .schub directory found.");
-  }
-
-  const options = parseTaskListOptions(args);
-  const tasks = listTasks(schubDir, options.statuses);
-
-  if (options.json) {
-    process.stdout.write(`${JSON.stringify(tasks, null, 2)}\n`);
-    return;
-  }
-
-  const lines = tasks.map((task) => `${task.id} ${task.title} (${task.status})`);
-  process.stdout.write(`${lines.join("\n")}\n`);
-};
-
-const runTasksCreate = (args: string[]) => {
-  const options = parseTaskCreateOptions(args);
-  const schubDir = resolveChangeRoot(getStartDir());
-  const created = createTask(schubDir, options);
-
-  for (const taskPath of created) {
-    process.stdout.write(`[OK] Wrote task: ${taskPath}\n`);
-  }
-};
-
-const runBiome = (command: "lint" | "format"): void => {
-  const workspaceRoot = getWorkspaceRoot();
-  const biomeArgs = command === "lint" ? ["lint", "."] : ["format", ".", "--write"];
-  const result = spawnSync({
-    cmd: ["bunx", "@biomejs/biome", ...biomeArgs],
-    cwd: workspaceRoot,
-    env: process.env,
-  });
-
-  if (result.stdout && result.stdout.length > 0) {
-    process.stdout.write(result.stdout);
-  }
-
-  if (result.stderr && result.stderr.length > 0) {
-    process.stderr.write(result.stderr);
-  }
-
-  process.exitCode = result.exitCode ?? 1;
-};
-
-const runChangesCreate = (args: string[]) => {
-  const options = parseChangeCreateOptions(args);
-  const schubDir = resolveChangeRoot(getStartDir());
-  const proposalPath = createChange(schubDir, options);
-  process.stdout.write(`[OK] Wrote proposal: ${proposalPath}\n`);
-};
-
-const runProjectCreate = (args: string[]) => {
-  const options = parseProjectCreateOptions(args);
-  const outputs = createProject(getStartDir(), options);
-
-  for (const output of outputs) {
-    process.stdout.write(`[OK] Wrote ${output}\n`);
-  }
-};
-
 const registerTerminalReset = () => {
   process.once("exit", () => {
     applyTerminalReset();
@@ -398,7 +51,7 @@ const runUi = () => {
   render(React.createElement(App));
 };
 
-const runCommand = (): void => {
+const runCommand = async () => {
   const args = process.argv.slice(2);
   if (args.length === 0) {
     runUi();
@@ -415,31 +68,57 @@ const runCommand = (): void => {
   switch (primary) {
     case "changes":
       if (secondary === "create") {
-        runChangesCreate(rest);
+        runChangesCreate(rest, getStartDir());
+        return;
+      }
+      if (secondary === "status") {
+        runChangesStatus(rest, getStartDir());
         return;
       }
       break;
     case "project":
       if (secondary === "create") {
-        runProjectCreate(rest);
+        runProjectCreate(rest, getStartDir());
         return;
       }
       break;
     case "tasks":
       if (secondary === "list") {
-        runTasksList(rest);
+        runTasksList(resolveSchubDir(), rest);
         return;
       }
       if (secondary === "create") {
-        runTasksCreate(rest);
+        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 "lint":
-      runBiome("lint");
+    case "eject":
+      runEject(args.slice(1), getStartDir());
       return;
-    case "format":
-      runBiome("format");
+    case "init":
+      await runInit(args.slice(1), getStartDir());
       return;
     case "ui":
       runUi();
@@ -449,10 +128,8 @@ const runCommand = (): void => {
   printHelp(1);
 };
 
-try {
-  runCommand();
-} catch (error) {
+runCommand().catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
   process.stderr.write(`${message}\n`);
   process.exitCode = 1;
-}
+});

package/src/init.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { initSchubRoot } from "./init";
+
+const createRepoFixture = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-init-root-"));
+  const repoRoot = join(base, "repo");
+  const startDir = join(repoRoot, "nested", "dir");
+  mkdirSync(startDir, { recursive: true });
+  return { base, repoRoot, startDir };
+};
+
+test("initSchubRoot resolves git worktree root and creates .schub", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const result = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(result.status).toBe(0);
+
+  const schubRoot = initSchubRoot(startDir);
+
+  expect(realpathSync(schubRoot)).toBe(realpathSync(join(repoRoot, ".schub")));
+  expect(existsSync(schubRoot)).toBe(true);
+  expect(statSync(schubRoot).isDirectory()).toBe(true);
+});
+
+test("initSchubRoot falls back to startDir when git is unavailable", () => {
+  const { startDir } = createRepoFixture();
+  const originalPath = process.env.PATH;
+  process.env.PATH = "";
+
+  try {
+    const schubRoot = initSchubRoot(startDir);
+
+    expect(schubRoot).toBe(join(startDir, ".schub"));
+    expect(existsSync(schubRoot)).toBe(true);
+    expect(statSync(schubRoot).isDirectory()).toBe(true);
+  } finally {
+    process.env.PATH = originalPath;
+  }
+});

package/src/init.ts

@@ -0,0 +1,27 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export const resolveGitRoot = (startDir: string) => {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: startDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+
+  if (result.status !== 0) {
+    return null;
+  }
+
+  const output = result.stdout?.trim();
+  return output ? resolve(output) : null;
+};
+
+export const initSchubRoot = (startDir: string = process.cwd()) => {
+  const resolvedStart = resolve(startDir);
+  const gitRoot = resolveGitRoot(resolvedStart);
+  const root = gitRoot ?? resolvedStart;
+  const schubRoot = join(root, ".schub");
+  mkdirSync(schubRoot, { recursive: true });
+  return schubRoot;
+};

package/src/project.ts

@@ -1,6 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveSchubRoot } from "./schub-root";
+import { resolveTemplatePath } from "./templates";
 
 type ProjectCreateOptions = {
   repoRoot?: string;
@@ -16,36 +18,6 @@ const TEMPLATE_FILES = {
 
 const TEMPLATES_ROOT = fileURLToPath(new URL("../templates/setup-project", import.meta.url));
 
-const isDirectory = (path: string) => {
-  try {
-    return statSync(path).isDirectory();
-  } catch {
-    return false;
-  }
-};
-
-const resolveSchubRoot = (startDir: string) => {
-  let current = resolve(startDir);
-  const fallback = join(current, ".schub");
-
-  while (true) {
-    if (basename(current) === ".schub" && isDirectory(current)) {
-      return current;
-    }
-
-    const candidate = join(current, ".schub");
-    if (isDirectory(candidate)) {
-      return candidate;
-    }
-
-    const parent = dirname(current);
-    if (parent === current) {
-      return fallback;
-    }
-    current = parent;
-  }
-};
-
 const readTemplate = (path: string) => {
   try {
     return readFileSync(path, "utf8");
@@ -84,7 +56,8 @@ export const createProject = (startDir: string, options: ProjectCreateOptions) =
   const created: string[] = [];
 
   for (const [outputName, templateName] of Object.entries(TEMPLATE_FILES)) {
-    const templatePath = join(TEMPLATES_ROOT, templateName);
+    const bundledPath = join(TEMPLATES_ROOT, templateName);
+    const templatePath = resolveTemplatePath(schubRoot, join("setup-project", templateName), bundledPath);
     const template = readTemplate(templatePath);
     const rendered = template.split("[Project Name]").join(projectName);
     const outputPath = join(schubRoot, outputName);

package/src/schub-root.ts

@@ -0,0 +1,33 @@
+import { statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+
+const isDirectory = (path: string) => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+export const resolveSchubRoot = (startDir: string = process.cwd()) => {
+  const start = resolve(startDir);
+  const fallback = join(start, ".schub");
+  let current = start;
+
+  while (true) {
+    if (basename(current) === ".schub" && isDirectory(current)) {
+      return current;
+    }
+
+    const candidate = join(current, ".schub");
+    if (isDirectory(candidate)) {
+      return candidate;
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return fallback;
+    }
+    current = parent;
+  }
+};

package/src/templates.ts

@@ -0,0 +1,18 @@
+import { statSync } from "node:fs";
+import { join } from "node:path";
+
+const isFile = (path: string) => {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+};
+
+export const resolveTemplatePath = (schubDir: string, templatePath: string, bundledPath: string) => {
+  const localPath = join(schubDir, "templates", templatePath);
+  if (isFile(localPath)) {
+    return localPath;
+  }
+  return bundledPath;
+};