schub 0.1.1 → 0.1.2

package/src/components/StatusView.tsx

@@ -1,8 +1,9 @@
+import { dirname, normalize, sep } from "node:path";
 import { Box, Text, useInput } from "ink";
-import { normalize, sep } from "node:path";
 import React from "react";
-import { type ChangeInfo, listChanges } from "../changes";
+import { type ChangeInfo, listChanges, updateChangeStatus } from "../changes";
 import { findSchubRoot, loadTaskDependencies, type TaskInfo, trimTaskTitle } from "../features/tasks";
+import { openInVsCode } from "../ide";
 
 type StatusSortable = {
   id: string;
@@ -10,6 +11,22 @@ type StatusSortable = {
   status: string;
 };
 
+type StatusViewProps = {
+  refreshIntervalMs?: number;
+  onCopyId: (id: string) => void;
+};
+
+const DEFAULT_REFRESH_INTERVAL_MS = 1000;
+const ACTIVE_TASK_STATUSES = ["blocked", "wip", "ready", "backlog"] as const;
+const CHANGE_TASK_STATUSES = [...ACTIVE_TASK_STATUSES, "done"] as const;
+
+type ChangeTaskCount = {
+  completed: number;
+  total: number;
+};
+
+const AUTO_MARK_STATUSES = new Set(["accepted", "wip"]);
+
 const compareText = (left: string, right: string): number =>
   left.localeCompare(right, undefined, { sensitivity: "base" });
 
@@ -32,20 +49,59 @@ const isTaskItem = (item: ChangeInfo | TaskInfo): item is TaskInfo => {
   return parts.includes("tasks");
 };
 
+const formatChangeId = (value: string) => {
+  const match = value.match(/^([Cc]\d{3})_/);
+  return match ? match[1].toUpperCase() : value;
+};
+
+const canAutoMarkChange = (status: string) => AUTO_MARK_STATUSES.has(status.trim().toLowerCase());
+
+const autoMarkChangesDone = (schubDir: string) => {
+  const allTasks = loadTaskDependencies(schubDir, CHANGE_TASK_STATUSES);
+  const changeTaskCounts = new Map<string, ChangeTaskCount>();
+
+  for (const task of allTasks) {
+    if (!task.changeId) {
+      continue;
+    }
+
+    const current = changeTaskCounts.get(task.changeId) ?? { completed: 0, total: 0 };
+    const completed = current.completed + (task.status === "done" ? 1 : 0);
+    changeTaskCounts.set(task.changeId, { completed, total: current.total + 1 });
+  }
+
+  if (changeTaskCounts.size === 0) {
+    return;
+  }
+
+  for (const change of listChanges(schubDir)) {
+    const counts = changeTaskCounts.get(change.id);
+    if (!counts || counts.total === 0 || counts.completed !== counts.total) {
+      continue;
+    }
+
+    if (canAutoMarkChange(change.status)) {
+      updateChangeStatus(schubDir, change.id, "Done");
+    }
+  }
+};
+
 const buildStatusData = (schubDir: string | null) => {
   if (!schubDir) {
     return {
       pendingReview: [],
       pendingImplementation: [],
+      pendingImplementationNoTasks: [],
       drafts: [],
       blocked: [],
       wip: [],
       ready: [],
       backlog: [],
+      pendingImplementationCounts: new Map<string, string>(),
     };
   }
 
-  const allTasks = loadTaskDependencies(schubDir, ["blocked", "wip", "ready", "backlog"]);
+  const allTasks = loadTaskDependencies(schubDir, CHANGE_TASK_STATUSES);
 
   const blockedTasks: TaskInfo[] = [];
   const wipTasks: TaskInfo[] = [];
@@ -53,17 +109,23 @@ const buildStatusData = (schubDir: string | null) => {
   const backlogTasks: TaskInfo[] = [];
 
   const activeChangeIds = new Set<string>();
+  const changeTaskCounts = new Map<string, ChangeTaskCount>();
 
   for (const task of allTasks) {
-    const s = task.status.toLowerCase();
-    if (s === "blocked") blockedTasks.push(task);
-    else if (s === "wip") wipTasks.push(task);
-    else if (s === "ready") readyTasks.push(task);
-    else if (s === "backlog") backlogTasks.push(task);
+    if (task.status === "blocked") blockedTasks.push(task);
+    else if (task.status === "wip") wipTasks.push(task);
+    else if (task.status === "ready") readyTasks.push(task);
+    else if (task.status === "backlog") backlogTasks.push(task);
 
-    if (task.changeId) {
+    if (task.changeId && task.status !== "done") {
       activeChangeIds.add(task.changeId);
     }
+
+    if (task.changeId) {
+      const current = changeTaskCounts.get(task.changeId) ?? { completed: 0, total: 0 };
+      const completed = current.completed + (task.status === "done" ? 1 : 0);
+      changeTaskCounts.set(task.changeId, { completed, total: current.total + 1 });
+    }
   }
 
   const allChanges = listChanges(schubDir);
@@ -75,37 +137,99 @@ const buildStatusData = (schubDir: string | null) => {
     const normalized = change.status.toLowerCase();
     if (normalized.includes("review")) {
       pendingReviewChanges.push(change);
-    } else if (
-      activeChangeIds.has(change.id) ||
-      normalized.includes("implementing") ||
-      normalized.includes("accepted")
-    ) {
+      continue;
+    }
+
+    const counts = changeTaskCounts.get(change.id);
+    const allTasksCompleted = Boolean(counts && counts.total > 0 && counts.completed === counts.total);
+
+    if (activeChangeIds.has(change.id)) {
       pendingImplementationChanges.push(change);
-    } else if (normalized.includes("draft")) {
+      continue;
+    }
+
+    if ((normalized.includes("implementing") || normalized.includes("accepted")) && !allTasksCompleted) {
+      pendingImplementationChanges.push(change);
+      continue;
+    }
+
+    if (normalized.includes("draft")) {
       draftChanges.push(change);
     }
   }
 
+  const pendingImplementationWithTasks: ChangeInfo[] = [];
+  const pendingImplementationNoTasks: ChangeInfo[] = [];
+  const pendingImplementationCounts = new Map<string, string>();
+
+  for (const change of pendingImplementationChanges.sort(sortByStatusThenTitle)) {
+    const counts = changeTaskCounts.get(change.id);
+    if (counts && counts.total > 0) {
+      pendingImplementationWithTasks.push(change);
+      pendingImplementationCounts.set(change.id, `${counts.completed}/${counts.total}`);
+    } else {
+      pendingImplementationNoTasks.push(change);
+    }
+  }
+
   return {
     pendingReview: pendingReviewChanges.sort(sortByStatusThenTitle),
-    pendingImplementation: pendingImplementationChanges.sort(sortByStatusThenTitle),
+    pendingImplementation: pendingImplementationWithTasks,
+    pendingImplementationNoTasks,
     drafts: draftChanges.sort(sortByStatusThenTitle),
     blocked: blockedTasks.sort(sortByStatusThenTitle),
     wip: wipTasks.sort(sortByStatusThenTitle),
     ready: readyTasks.sort(sortByStatusThenTitle),
     backlog: backlogTasks.sort(sortByStatusThenTitle),
+    pendingImplementationCounts,
   };
 };
 
-export default function StatusView() {
+export default function StatusView({ refreshIntervalMs = DEFAULT_REFRESH_INTERVAL_MS, onCopyId }: StatusViewProps) {
   const schubDir = findSchubRoot();
-  const { pendingReview, pendingImplementation, drafts, blocked, wip, ready, backlog } = buildStatusData(schubDir);
-
-  const allItems = [...pendingReview, ...pendingImplementation, ...drafts, ...blocked, ...wip, ...ready, ...backlog];
+  const [, setRefreshTick] = React.useState(0);
+  const {
+    pendingReview,
+    pendingImplementation,
+    pendingImplementationNoTasks,
+    drafts,
+    blocked,
+    wip,
+    ready,
+    backlog,
+    pendingImplementationCounts,
+  } = buildStatusData(schubDir);
+  const repoRoot = schubDir ? dirname(schubDir) : "";
+
+  const allItems = [
+    ...pendingReview,
+    ...pendingImplementation,
+    ...pendingImplementationNoTasks,
+    ...drafts,
+    ...blocked,
+    ...wip,
+    ...ready,
+    ...backlog,
+  ];
 
   const [selection, setSelection] = React.useState(0);
   const totalItems = allItems.length;
 
+  React.useEffect(() => {
+    if (!schubDir) {
+      return;
+    }
+
+    const interval = setInterval(() => {
+      autoMarkChangesDone(schubDir);
+      setRefreshTick((current) => current + 1);
+    }, refreshIntervalMs);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, [refreshIntervalMs, schubDir]);
+
   React.useEffect(() => {
     if (totalItems === 0) {
       setSelection(0);
@@ -114,7 +238,7 @@ export default function StatusView() {
     setSelection((current) => Math.min(current, totalItems - 1));
   }, [totalItems]);
 
-  useInput((_input, key) => {
+  useInput((input, key) => {
     if (totalItems === 0) {
       return;
     }
@@ -126,6 +250,16 @@ export default function StatusView() {
     if (key.upArrow) {
       setSelection((current) => Math.max(current - 1, 0));
     }
+
+    if (input === "o") {
+      const selectedItem = allItems[selection];
+      openInVsCode(repoRoot, selectedItem.path);
+    }
+
+    if (input === "c") {
+      const selectedItem = allItems[selection];
+      onCopyId(selectedItem.id);
+    }
   });
 
   if (!schubDir) {
@@ -145,7 +279,7 @@ export default function StatusView() {
     );
   }
 
-  const renderRow = (item: ChangeInfo | TaskInfo, index: number) => {
+  const renderRow = (item: ChangeInfo | TaskInfo, index: number, detail?: string) => {
     const selected = index === selection;
     const task = isTaskItem(item) ? item : null;
     const title = task ? trimTaskTitle(task.title) : "";
@@ -153,14 +287,17 @@ export default function StatusView() {
       task && task.status === "wip" && typeof task.checklistTotal === "number"
         ? ` (${task.checklistRemaining ?? 0}/${task.checklistTotal})`
         : "";
-    const displayTitle = title ? `${title}${checklistIndicator}` : "";
+    const changeTitle = item.title;
+    const changeDetail = detail ? ` ${detail}` : "";
+    const displayTitle = task ? `${title}${checklistIndicator}` : `${changeTitle}${changeDetail}`.trim();
+    const displayId = task ? item.id : formatChangeId(item.id);
 
     return (
       <Box key={item.id} marginLeft={1}>
         <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
         <Box marginLeft={1}>
           <Text color="white" bold={selected}>
-            {item.id}
+            {displayId}
           </Text>
           {displayTitle ? <Text color="gray"> {displayTitle}</Text> : null}
         </Box>
@@ -170,11 +307,11 @@ export default function StatusView() {
 
   let currentIndex = 0;
 
-  const renderSection = (title: string, items: (ChangeInfo | TaskInfo)[]) => {
+  const renderSection = (title: string, items: (ChangeInfo | TaskInfo)[], detailById?: Map<string, string>) => {
     if (items.length === 0) return null;
 
     const sectionStartIndex = currentIndex;
-    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i));
+    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i, detailById?.get(item.id)));
     currentIndex += items.length;
 
     return (
@@ -191,23 +328,27 @@ export default function StatusView() {
     <Box flexDirection="column">
       <Box flexDirection="column" marginBottom={1}>
         <Box marginBottom={1}>
-          <Text bold color="white" underline>
+          <Text bold color="white">
             Change Proposals
           </Text>
         </Box>
         {renderSection("Pending Review", pendingReview)}
-        {renderSection("Pending Implementation", pendingImplementation)}
+        {renderSection("Pending Implementation", pendingImplementation, pendingImplementationCounts)}
+        {renderSection("No Tasks Defined", pendingImplementationNoTasks)}
         {renderSection("Drafts", drafts)}
-        {pendingReview.length === 0 && pendingImplementation.length === 0 && drafts.length === 0 && (
-          <Box marginLeft={1}>
-            <Text color="gray">No active proposals.</Text>
-          </Box>
-        )}
+        {pendingReview.length === 0 &&
+          pendingImplementation.length === 0 &&
+          pendingImplementationNoTasks.length === 0 &&
+          drafts.length === 0 && (
+            <Box marginLeft={1}>
+              <Text color="gray">No active proposals.</Text>
+            </Box>
+          )}
       </Box>
 
       <Box flexDirection="column">
         <Box marginBottom={1}>
-          <Text bold color="white" underline>
+          <Text bold color="white">
             Tasks
           </Text>
         </Box>

package/src/features/tasks/create.ts

@@ -1,14 +1,22 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-
-const TASK_TEMPLATE_PATH = fileURLToPath(new URL("../../../templates/create-tasks/task-template.md", import.meta.url));
-
-const readTaskTemplate = () => {
+import { resolveTemplatePath } from "../../templates";
+
+const BUNDLED_TASK_TEMPLATE_PATH = fileURLToPath(
+  new URL("../../../templates/create-tasks/task-template.md", import.meta.url),
+);
+
+const readTaskTemplate = (schubDir: string) => {
+  const templatePath = resolveTemplatePath(
+    schubDir,
+    join("create-tasks", "task-template.md"),
+    BUNDLED_TASK_TEMPLATE_PATH,
+  );
   try {
-    return readFileSync(TASK_TEMPLATE_PATH, "utf8");
+    return readFileSync(templatePath, "utf8");
   } catch {
-    throw new Error(`[ERROR] Template not found: ${TASK_TEMPLATE_PATH}`);
+    throw new Error(`[ERROR] Template not found: ${templatePath}`);
   }
 };
 
@@ -89,7 +97,7 @@ export const createTask = (
   let nextNumber = existingNumbers.size > 0 ? Math.max(...existingNumbers) + 1 : 1;
   const statusDir = join(tasksRoot, status);
   mkdirSync(statusDir, { recursive: true });
-  const template = readTaskTemplate();
+  const template = readTaskTemplate(schubDir);
 
   const createdPaths: string[] = [];
 

package/src/features/tasks/filesystem.test.ts

@@ -0,0 +1,78 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listTasks, loadTaskDependencies } from "./filesystem";
+
+const setupChecklistRepo = () => {
+  const base = mkdtempSync(join(tmpdir(), "schub-checklist-"));
+  const schubDir = join(base, ".schub");
+  const tasksRoot = join(schubDir, "tasks", "backlog");
+  mkdirSync(tasksRoot, { recursive: true });
+
+  const tasks = [
+    {
+      id: "T001",
+      slug: "unchecked-only",
+      body: `# Task: T001 Unchecked Only\n\n## Steps\n- [ ] First item\n- [ ] Second item\n`,
+    },
+    {
+      id: "T002",
+      slug: "checked-only",
+      body: `# Task: T002 Checked Only\n\n## Steps\n- [x] Finished item\n`,
+    },
+    {
+      id: "T003",
+      slug: "mixed-checklist",
+      body: `# Task: T003 Mixed Checklist\n\n## Steps\n- [ ] Remaining item\n- [x] Done item\n\n## Acceptance\n- [ ] Ignore this\n`,
+    },
+    {
+      id: "T004",
+      slug: "missing-checklist",
+      body: `# Task: T004 Missing Checklist\n\n## Steps\n- Do the thing\n- Another item\n\n## Acceptance\n- [ ] Ignore this too\n`,
+    },
+  ];
+
+  for (const task of tasks) {
+    const filePath = join(tasksRoot, `${task.id}_${task.slug}.md`);
+    writeFileSync(filePath, task.body, "utf8");
+  }
+
+  return schubDir;
+};
+
+const getTaskById = <T extends { id: string }>(tasks: T[], id: string) => {
+  return tasks.find((task) => task.id === id);
+};
+
+test("listTasks includes Steps-only checklist counts", () => {
+  const schubDir = setupChecklistRepo();
+  const tasks = listTasks(schubDir);
+
+  const unchecked = getTaskById(tasks, "T001");
+  const checked = getTaskById(tasks, "T002");
+  const mixed = getTaskById(tasks, "T003");
+  const missing = getTaskById(tasks, "T004");
+
+  expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
+  expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
+  expect(mixed).toMatchObject({ checklistTotal: 2, checklistRemaining: 1 });
+  expect(missing?.checklistTotal).toBeUndefined();
+  expect(missing?.checklistRemaining).toBeUndefined();
+});
+
+test("loadTaskDependencies includes Steps-only checklist counts", () => {
+  const schubDir = setupChecklistRepo();
+  const tasks = loadTaskDependencies(schubDir);
+
+  const unchecked = getTaskById(tasks, "T001");
+  const checked = getTaskById(tasks, "T002");
+  const mixed = getTaskById(tasks, "T003");
+  const missing = getTaskById(tasks, "T004");
+
+  expect(unchecked).toMatchObject({ checklistTotal: 2, checklistRemaining: 2 });
+  expect(checked).toMatchObject({ checklistTotal: 1, checklistRemaining: 0 });
+  expect(mixed).toMatchObject({ checklistTotal: 2, checklistRemaining: 1 });
+  expect(missing?.checklistTotal).toBeUndefined();
+  expect(missing?.checklistRemaining).toBeUndefined();
+});

package/src/features/tasks/filesystem.ts

@@ -104,10 +104,6 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
     return { ...fallback, dependsOn: [] };
   }
 
-  const headerMatch = content.match(/^#\s*Task:\s*(\S+)\s+(.+)$/m);
-  const id = headerMatch?.[1] ?? fallback.id;
-  const title = headerMatch?.[2]?.trim() ?? fallback.title;
-
   const changeIdMatch = content.match(/^\*\*Change ID\*\*:\s*\[?`?([^\]`]+)`?]?/m);
   const changeId = changeIdMatch?.[1]?.trim();
 
@@ -126,8 +122,8 @@ const parseTaskFile = (filePath: string, fallback: { id: string; title: string }
   const checklistCounts = parseChecklistCounts(content);
 
   return {
-    id,
-    title,
+    id: fallback.id,
+    title: fallback.title,
     dependsOn,
     changeId,
     ...(checklistCounts ?? {}),
@@ -220,8 +216,8 @@ export const loadTaskDependencies = (
       const dependsOn = parsedFile.dependsOn.sort(compareTaskIds);
 
       tasks.push({
-        id: parsedFile.id,
-        title: parsedFile.title,
+        id: parsed.id,
+        title: parsed.title,
         status,
         path: relative(repoRoot, filePath),
         dependsOn,

package/src/ide.ts

@@ -0,0 +1,7 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+
+export const openInVsCode = (repoRoot: string, relativePath: string) => {
+  const targetPath = resolve(repoRoot, relativePath);
+  spawn("code", ["-g", targetPath], { stdio: "ignore" }).unref();
+};

package/src/index.test.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "bun";
+
+test("schub help lists tasks list", () => {
+  const testDir = dirname(fileURLToPath(import.meta.url));
+  const cliDir = resolve(testDir, "..");
+  const result = spawnSync({
+    cmd: ["bun", "run", "schub", "--help"],
+    cwd: cliDir,
+  });
+
+  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).not.toContain("lint");
+  expect(stdout).not.toContain("format");
+});

package/src/index.ts

@@ -3,8 +3,10 @@ import { render } from "ink";
 import React from "react";
 import App from "./App";
 import { runAdrCreate } from "./commands/adr";
-import { runChangesCreate } from "./commands/changes";
+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";
@@ -15,6 +17,7 @@ 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
@@ -22,6 +25,8 @@ Commands:
   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
 `;
 
@@ -46,7 +51,7 @@ const runUi = () => {
   render(React.createElement(App));
 };
 
-const runCommand = () => {
+const runCommand = async () => {
   const args = process.argv.slice(2);
   if (args.length === 0) {
     runUi();
@@ -66,6 +71,10 @@ const runCommand = () => {
         runChangesCreate(rest, getStartDir());
         return;
       }
+      if (secondary === "status") {
+        runChangesStatus(rest, getStartDir());
+        return;
+      }
       break;
     case "project":
       if (secondary === "create") {
@@ -105,6 +114,12 @@ const runCommand = () => {
         return;
       }
       break;
+    case "eject":
+      runEject(args.slice(1), getStartDir());
+      return;
+    case "init":
+      await runInit(args.slice(1), getStartDir());
+      return;
     case "ui":
       runUi();
       return;
@@ -113,10 +128,8 @@ const runCommand = () => {
   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;
+};