schub 0.1.2 → 0.1.4

package/src/commands/changes.ts

@@ -1,4 +1,5 @@
-import { createChange, resolveChangeRoot, updateChangeStatus } from "../changes";
+import { archiveChange, createChange, listChanges, resolveChangeRoot, updateChangeStatus } from "../changes";
+import { archiveTasksForChange } from "../tasks";
 
 type ChangeCreateOptions = {
   changeId?: string;
@@ -12,6 +13,11 @@ type ChangeStatusOptions = {
   status: string;
 };
 
+type ChangeArchiveOptions = {
+  changeId: string;
+  skipTasks: boolean;
+};
+
 const parseChangeCreateOptions = (args: string[]) => {
   let changeId: string | undefined;
   let title: string | undefined;
@@ -148,6 +154,82 @@ const parseChangeStatusOptions = (args: string[]) => {
   return options;
 };
 
+const parseChangeArchiveOptions = (args: string[]) => {
+  let changeId: string | undefined;
+  let skipTasks = 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 === "--skip-tasks") {
+      skipTasks = 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.");
+  }
+
+  const options: ChangeArchiveOptions = { changeId, skipTasks };
+  return options;
+};
+
+const parseChangeListOptions = (args: string[]) => {
+  const unknown: string[] = [];
+
+  const rejectUnsupported = (flag: string) => {
+    throw new Error(`Unsupported option: ${flag}.`);
+  };
+
+  for (const arg of args) {
+    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(", ")}`);
+  }
+};
+
 export const runChangesCreate = (args: string[], startDir: string) => {
   const options = parseChangeCreateOptions(args);
   const schubDir = resolveChangeRoot(startDir);
@@ -161,3 +243,22 @@ export const runChangesStatus = (args: string[], startDir: string) => {
   const updated = updateChangeStatus(schubDir, options.changeId, options.status);
   process.stdout.write(`[OK] Updated status for ${updated.changeId}: ${updated.previousStatus} -> ${updated.status}\n`);
 };
+
+export const runChangesArchive = (args: string[], startDir: string) => {
+  const options = parseChangeArchiveOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const archived = archiveChange(schubDir, options.changeId);
+  const archivedTasks = options.skipTasks ? [] : archiveTasksForChange(schubDir, archived.changeId);
+  const taskLabel = options.skipTasks
+    ? "tasks kept"
+    : `${archivedTasks.length} task${archivedTasks.length === 1 ? "" : "s"} archived`;
+  process.stdout.write(`[OK] Archived change ${archived.changeId} (${taskLabel})\n`);
+};
+
+export const runChangesList = (args: string[], startDir: string) => {
+  parseChangeListOptions(args);
+  const schubDir = resolveChangeRoot(startDir);
+  const changes = listChanges(schubDir);
+  const lines = changes.map((change) => `${change.id} ${change.title} (${change.status})`);
+  process.stdout.write(`${lines.join("\n")}\n`);
+};

package/src/commands/cookbook.test.ts

@@ -37,19 +37,20 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
   const proposal = [
+    "---",
+    `change_id: ${changeId}`,
+    "created: 2024-01-01",
+    "status: Draft",
+    "---",
     `# Proposal - ${title}`,
     "",
-    `**Change ID**: \`${changeId}\``,
-    "**Created**: 2024-01-01",
-    "**Status**: Draft",
-    "",
   ].join("\n");
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };
 
 test("cookbook create scaffolds cookbook file", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C004_new-cookbook";
+  const changeId = "C0004_new-cookbook";
   const changeTitle = "New Cookbook";
   seedChange(schubRoot, changeId, changeTitle);
 

package/src/commands/init.test.ts

@@ -3,7 +3,13 @@ import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { installCodexSkills, resolveCodexSkillsRoot, selectProviders } from "./init";
+import {
+  installCodexSkills,
+  installOpencodeSkills,
+  resolveCodexSkillsRoot,
+  resolveOpencodeSkillsRoot,
+  selectProviders,
+} from "./init";
 
 const createRepoFixture = () => {
   const base = mkdtempSync(join(tmpdir(), "schub-init-codex-"));
@@ -15,7 +21,9 @@ const createRepoFixture = () => {
 
 test("selectProviders handles numeric and named inputs", () => {
   expect(selectProviders("1")).toEqual(["codex"]);
-  expect(selectProviders("codex, 1")).toEqual(["codex"]);
+  expect(selectProviders("2")).toEqual(["opencode"]);
+  expect(selectProviders("codex, opencode")).toEqual(["codex", "opencode"]);
+  expect(selectProviders("Opencode, 1")).toEqual(["opencode", "codex"]);
 });
 
 test("resolveCodexSkillsRoot prefers worktree .codex when present", () => {
@@ -63,6 +71,51 @@ test("resolveCodexSkillsRoot uses cwd when git is unavailable", () => {
   }
 });
 
+test("resolveOpencodeSkillsRoot prefers worktree .opencode when present", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const gitInit = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(gitInit.status).toBe(0);
+
+  mkdirSync(join(repoRoot, ".opencode"), { recursive: true });
+
+  const destination = resolveOpencodeSkillsRoot(startDir);
+  const expectedRoot = realpathSync(repoRoot);
+
+  expect(destination).toBe(join(expectedRoot, ".opencode", "skills"));
+});
+
+test("resolveOpencodeSkillsRoot falls back to home when worktree .opencode is missing", () => {
+  const { repoRoot, startDir } = createRepoFixture();
+  const gitInit = spawnSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+
+  expect(gitInit.status).toBe(0);
+
+  const originalHome = process.env.HOME;
+  const homeDir = mkdtempSync(join(tmpdir(), "schub-home-"));
+  process.env.HOME = homeDir;
+
+  try {
+    const destination = resolveOpencodeSkillsRoot(startDir);
+    expect(destination).toBe(join(homeDir, ".opencode", "skills"));
+  } finally {
+    process.env.HOME = originalHome;
+  }
+});
+
+test("resolveOpencodeSkillsRoot uses cwd when git is unavailable", () => {
+  const { startDir } = createRepoFixture();
+  const originalPath = process.env.PATH;
+  process.env.PATH = "";
+
+  try {
+    const destination = resolveOpencodeSkillsRoot(startDir);
+    expect(destination).toBe(join(startDir, ".opencode", "skills"));
+  } finally {
+    process.env.PATH = originalPath;
+  }
+});
+
 test("installCodexSkills skips existing skill directories", () => {
   const base = mkdtempSync(join(tmpdir(), "schub-init-install-"));
   const destination = join(base, "skills");
@@ -76,3 +129,17 @@ test("installCodexSkills skips existing skill directories", () => {
   expect(installed.length).toBeGreaterThan(0);
   expect(existsSync(join(destination, "create-tasks", "SKILL.md"))).toBe(true);
 });
+
+test("installOpencodeSkills skips existing skill directories", () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-init-opencode-install-"));
+  const destination = join(base, "skills");
+  const existingSkill = join(destination, "review-proposal");
+  mkdirSync(existingSkill, { recursive: true });
+  writeFileSync(join(existingSkill, "SKILL.md"), "existing", "utf8");
+
+  const { installed, skipped } = installOpencodeSkills(destination);
+
+  expect(skipped).toContain("review-proposal");
+  expect(installed.length).toBeGreaterThan(0);
+  expect(existsSync(join(destination, "create-tasks", "SKILL.md"))).toBe(true);
+});

package/src/commands/init.ts

@@ -3,16 +3,20 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
+import { ensureRoadmapFile } from "../features/roadmap";
 import { initSchubRoot, resolveGitRoot } from "../init";
 
-type ProviderId = "codex";
+type ProviderId = "codex" | "opencode";
 
 type ProviderOption = {
   id: ProviderId;
   label: string;
 };
 
-const PROVIDERS: ProviderOption[] = [{ id: "codex", label: "Codex" }];
+const PROVIDERS: ProviderOption[] = [
+  { id: "codex", label: "Codex" },
+  { id: "opencode", label: "Opencode" },
+];
 const BUNDLED_SKILLS_ROOT = fileURLToPath(new URL("../../skills", import.meta.url));
 
 const isDirectory = (path: string) => {
@@ -82,7 +86,24 @@ export const resolveCodexSkillsRoot = (startDir: string) => {
   return join(home, ".codex", "skills");
 };
 
-export const installCodexSkills = (destination: string) => {
+export const resolveOpencodeSkillsRoot = (startDir: string) => {
+  const resolvedStart = resolve(startDir);
+  const gitRoot = resolveGitRoot(resolvedStart);
+
+  if (!gitRoot) {
+    return join(resolvedStart, ".opencode", "skills");
+  }
+
+  const localOpencodeRoot = join(gitRoot, ".opencode");
+  if (isDirectory(localOpencodeRoot)) {
+    return join(localOpencodeRoot, "skills");
+  }
+
+  const home = process.env.HOME ?? homedir();
+  return join(home, ".opencode", "skills");
+};
+
+const installBundledSkills = (destination: string) => {
   mkdirSync(destination, { recursive: true });
 
   const entries = readdirSync(BUNDLED_SKILLS_ROOT, { withFileTypes: true });
@@ -109,8 +130,12 @@ export const installCodexSkills = (destination: string) => {
   return { installed, skipped };
 };
 
-const reportCodexInstall = (destination: string, installed: string[], skipped: string[]) => {
-  process.stdout.write(`[OK] Codex skills: ${destination}\n`);
+export const installCodexSkills = (destination: string) => installBundledSkills(destination);
+
+export const installOpencodeSkills = (destination: string) => installBundledSkills(destination);
+
+const reportSkillsInstall = (label: string, destination: string, installed: string[], skipped: string[]) => {
+  process.stdout.write(`[OK] ${label} skills: ${destination}\n`);
 
   for (const skill of installed) {
     process.stdout.write(`[OK] Installed ${skill}\n`);
@@ -121,6 +146,14 @@ const reportCodexInstall = (destination: string, installed: string[], skipped: s
   }
 };
 
+const reportCodexInstall = (destination: string, installed: string[], skipped: string[]) => {
+  reportSkillsInstall("Codex", destination, installed, skipped);
+};
+
+const reportOpencodeInstall = (destination: string, installed: string[], skipped: string[]) => {
+  reportSkillsInstall("Opencode", destination, installed, skipped);
+};
+
 const parseInitOptions = (args: string[]) => {
   if (args.length === 0) {
     return;
@@ -135,10 +168,20 @@ export const runInit = async (args: string[], startDir: string) => {
   const schubRoot = initSchubRoot(startDir);
   process.stdout.write(`[OK] Wrote ${schubRoot}\n`);
 
+  const roadmapResult = ensureRoadmapFile(schubRoot);
+  const roadmapStatus = roadmapResult.created ? "OK" : "SKIP";
+  process.stdout.write(`[${roadmapStatus}] Roadmap ${roadmapResult.path}\n`);
+
   const providers = await promptForProviders();
   if (providers.includes("codex")) {
     const destination = resolveCodexSkillsRoot(startDir);
     const { installed, skipped } = installCodexSkills(destination);
     reportCodexInstall(destination, installed, skipped);
   }
+
+  if (providers.includes("opencode")) {
+    const destination = resolveOpencodeSkillsRoot(startDir);
+    const { installed, skipped } = installOpencodeSkills(destination);
+    reportOpencodeInstall(destination, installed, skipped);
+  }
 };

package/src/commands/review.test.ts

@@ -37,19 +37,20 @@ const seedChange = (schubRoot: string, changeId: string, title: string) => {
   const changeDir = join(schubRoot, "changes", changeId);
   mkdirSync(changeDir, { recursive: true });
   const proposal = [
+    "---",
+    `change_id: ${changeId}`,
+    "created: 2024-01-01",
+    "status: Draft",
+    "---",
     `# Proposal - ${title}`,
     "",
-    `**Change ID**: \`${changeId}\``,
-    "**Created**: 2024-01-01",
-    "**Status**: Draft",
-    "",
   ].join("\n");
   writeFileSync(join(changeDir, "proposal.md"), proposal, "utf8");
 };
 
 test("review create scaffolds REVIEW_ME from template", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C001_sample-change";
+  const changeId = "C0001_sample-change";
   const changeTitle = "Sample Change";
   seedChange(schubRoot, changeId, changeTitle);
 
@@ -72,7 +73,7 @@ test("review create scaffolds REVIEW_ME from template", () => {
 
 test("review complete creates Q&A with review content", () => {
   const { cwd, schubRoot } = createRepo();
-  const changeId = "C002_review-complete";
+  const changeId = "C0002_review-complete";
   const changeTitle = "Review Complete";
   seedChange(schubRoot, changeId, changeTitle);
 

package/src/commands/review.ts

@@ -171,7 +171,7 @@ export const runReviewCreate = (args: string[], startDir: string) => {
 
   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).`,
+      `Invalid change-id '${options.changeId}'. Use kebab-case or a C-prefixed id (e.g., C1_add-user-auth).`,
     );
   }
 

package/src/commands/roadmap.test.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, mkdtempSync, readdirSync, 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 decoder = new TextDecoder();
+
+const runRoadmap = (schubCwd: string, args: string[] = []) => {
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "roadmap", ...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 createRoadmapRepo = (items: string[] = []) => {
+  const base = mkdtempSync(join(tmpdir(), "schub-roadmap-cli-"));
+  const repoRoot = join(base, "repo");
+  const cwd = join(repoRoot, "nested", "dir");
+  mkdirSync(cwd, { recursive: true });
+
+  const schubDir = join(repoRoot, ".schub");
+  mkdirSync(schubDir, { recursive: true });
+  const roadmapPath = join(schubDir, "roadmap.md");
+  const content = ["## Roadmap", "", ...items, ""].join("\n");
+  writeFileSync(roadmapPath, content, "utf8");
+
+  return { cwd, roadmapPath, schubDir };
+};
+
+test("roadmap list prints index and proposal refs", () => {
+  const { cwd } = createRoadmapRepo([
+    "- **<PROPOSAL_REF>**: As a user, I want to sign in.",
+    "- **C0001**: As an admin, I want to manage accounts.",
+  ]);
+
+  const { result, stdout } = runRoadmap(cwd, ["list"]);
+
+  expect(result.exitCode).toBe(0);
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  expect(lines).toEqual(["1 [--] As a user, I want to sign in.", "2 [C0001] As an admin, I want to manage accounts."]);
+});
+
+test("roadmap add appends a new story", () => {
+  const { cwd, roadmapPath } = createRoadmapRepo(["- **<PROPOSAL_REF>**: As a user, I want to sign in."]);
+
+  const { result } = runRoadmap(cwd, ["add", "As a guest, I want to browse."]);
+
+  expect(result.exitCode).toBe(0);
+  const content = readFileSync(roadmapPath, "utf8");
+  expect(content).toContain("- **<PROPOSAL_REF>**: As a guest, I want to browse.");
+});
+
+test("roadmap propose creates proposal and updates roadmap", () => {
+  const { cwd, roadmapPath, schubDir } = createRoadmapRepo(["- **<PROPOSAL_REF>**: As a user, I want to sign in."]);
+
+  const { result } = runRoadmap(cwd, ["propose", "1"]);
+
+  expect(result.exitCode).toBe(0);
+  const content = readFileSync(roadmapPath, "utf8");
+  expect(content).toContain("- **C0001**: As a user, I want to sign in.");
+
+  const changeDirs = readdirSync(join(schubDir, "changes"));
+  expect(changeDirs).toHaveLength(1);
+  expect(changeDirs[0]).toMatch(/^C0001_/);
+});
+
+test("roadmap propose errors when item already linked", () => {
+  const { cwd } = createRoadmapRepo(["- **C0003**: As a user, I want to sign in."]);
+
+  const { result, stderr } = runRoadmap(cwd, ["propose", "1"]);
+
+  expect(result.exitCode).not.toBe(0);
+  expect(stderr).toContain("already has a proposal ref");
+});

package/src/commands/roadmap.ts

@@ -0,0 +1,84 @@
+import { addRoadmapItem, listRoadmapItems, proposeRoadmapItem } from "../features/roadmap";
+import { findSchubRoot } from "../features/tasks";
+
+const resolveRoadmapRoot = (startDir: string) => {
+  const schubDir = findSchubRoot(startDir);
+  if (!schubDir) {
+    throw new Error("No .schub directory found.");
+  }
+  return schubDir;
+};
+
+const parseRoadmapAddOptions = (args: string[]) => {
+  const storyParts: string[] = [];
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    storyParts.push(arg);
+  }
+
+  const story = storyParts.join(" ").trim();
+  if (!story) {
+    throw new Error("Provide a roadmap story.");
+  }
+  return { story };
+};
+
+const parseRoadmapListOptions = (args: string[]) => {
+  if (args.length > 0) {
+    throw new Error(`Unknown option(s): ${args.join(", ")}`);
+  }
+};
+
+const parseRoadmapProposeOptions = (args: string[]) => {
+  if (args.length === 0) {
+    throw new Error("Provide a roadmap item index.");
+  }
+  if (args.length > 1) {
+    throw new Error(`Unknown option(s): ${args.slice(1).join(", ")}`);
+  }
+  const rawIndex = args[0];
+  if (!rawIndex || rawIndex.startsWith("--")) {
+    throw new Error("Provide a roadmap item index.");
+  }
+  const index = Number.parseInt(rawIndex, 10);
+  if (Number.isNaN(index) || index <= 0) {
+    throw new Error(`Invalid roadmap index '${rawIndex}'. Use a positive number.`);
+  }
+  return { index };
+};
+
+const formatRoadmapLine = (index: number, proposalRef: string | null, story: string) => {
+  const ref = proposalRef ?? "--";
+  return `${index} [${ref}] ${story}`;
+};
+
+export const runRoadmapList = (startDir: string, args: string[]) => {
+  parseRoadmapListOptions(args);
+  const schubDir = resolveRoadmapRoot(startDir);
+  const items = listRoadmapItems(schubDir);
+
+  if (items.length === 0) {
+    process.stdout.write("No roadmap items found.\n");
+    return;
+  }
+
+  const lines = items.map((item) => formatRoadmapLine(item.index, item.proposalRef, item.story));
+  process.stdout.write(`${lines.join("\n")}\n`);
+};
+
+export const runRoadmapAdd = (startDir: string, args: string[]) => {
+  const options = parseRoadmapAddOptions(args);
+  const schubDir = resolveRoadmapRoot(startDir);
+  addRoadmapItem(schubDir, options.story);
+  process.stdout.write("[OK] Added roadmap item.\n");
+};
+
+export const runRoadmapPropose = (startDir: string, args: string[]) => {
+  const options = parseRoadmapProposeOptions(args);
+  const schubDir = resolveRoadmapRoot(startDir);
+  const result = proposeRoadmapItem(schubDir, options.index);
+  process.stdout.write(`[OK] Wrote proposal: ${result.proposalPath}\n`);
+  process.stdout.write(`[OK] Updated roadmap item ${options.index} -> ${result.proposalRef}\n`);
+};