schub 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "schub",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "schub": "./src/index.ts"
+  },
+  "files": [
+    "dist",
+    "src",
+    "templates"
+  ],
+  "scripts": {
+    "schub": "bun ./src/index.ts",
+    "build": "bun build ./src/index.ts --outdir dist --target node",
+    "lint": "bunx @biomejs/biome lint .",
+    "format": "bunx @biomejs/biome format --write .",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "ink": "^6.6.0",
+    "react": "^19.2.3",
+    "react-devtools-core": "^6.1.2"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^24.3.0",
+    "@types/react": "^19.2.8",
+    "ink-testing-library": "^4.0.0"
+  }
+}

package/src/App.tsx

@@ -0,0 +1,103 @@
+import { homedir } from "node:os";
+import { Box, Text, useInput, useStdout } from "ink";
+import React from "react";
+import packageJson from "../package.json";
+import PlanView from "./components/PlanView";
+import StatusView from "./components/StatusView";
+import { findSchubRoot } from "./features/tasks";
+
+type Mode = "status" | "plan";
+
+type TabDefinition = {
+  id: Mode;
+  label: string;
+};
+
+const tabs: TabDefinition[] = [
+  { id: "status", label: "Status" },
+  { id: "plan", label: "Plan" },
+];
+
+export default function App() {
+  const [mode, setMode] = React.useState<Mode>("status");
+  const { stdout } = useStdout();
+  const [dimensions, setDimensions] = React.useState(() => ({
+    columns: stdout.columns,
+    rows: stdout.rows,
+  }));
+  const versionLabel = `${packageJson.version}`;
+  const homeDir = homedir();
+  const schubDir = findSchubRoot(process.env.SCHUB_CWD ?? process.cwd())!;
+  const displaySchubDir =
+    schubDir === homeDir ? "~" : schubDir.startsWith(`${homeDir}/`) ? `~${schubDir.slice(homeDir.length)}` : schubDir;
+
+  React.useEffect(() => {
+    const handleResize = () => {
+      setDimensions({ columns: stdout.columns, rows: stdout.rows });
+    };
+
+    stdout.on("resize", handleResize);
+
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+
+  useInput((_input, key) => {
+    if (key.tab) {
+      setMode((current) => (current === "status" ? "plan" : "status"));
+    }
+  });
+
+  return (
+    <Box backgroundColor="black" flexDirection="column" width={dimensions.columns} height={dimensions.rows}>
+      <Box flexDirection="column" paddingX={2} paddingY={1} flexShrink={0}>
+        <Box flexDirection="row" justifyContent="space-between" alignItems="center">
+          <Box flexDirection="row">
+            {tabs.map((tab) => {
+              const isSelected = mode === tab.id;
+              return (
+                <Box
+                  key={tab.id}
+                  marginRight={4}
+                  borderStyle="bold"
+                  borderLeft={isSelected}
+                  borderTop={false}
+                  borderRight={false}
+                  borderBottom={false}
+                  borderLeftColor={"blueBright"}
+                  flexDirection="row"
+                  alignItems="center"
+                  paddingLeft={1}
+                >
+                  <Text color={isSelected ? "white" : "gray"} bold={isSelected}>
+                    {tab.label}
+                  </Text>
+                </Box>
+              );
+            })}
+          </Box>
+        </Box>
+      </Box>
+      <Box flexDirection="column" paddingX={2} paddingY={1} flexGrow={1} flexShrink={1}>
+        {mode === "status" ? <StatusView /> : <PlanView />}
+      </Box>
+      <Box flexDirection="column" paddingX={2} paddingBottom={1} flexShrink={0}>
+        <Box justifyContent="flex-end">
+          <Box marginRight={2}>
+            <Text>tab</Text>
+            <Text color="gray"> switch mode</Text>
+          </Box>
+          <Box>
+            <Text>ctrl+p</Text>
+            <Text color="gray"> commands</Text>
+          </Box>
+        </Box>
+        <Box justifyContent="space-between" marginTop={1}>
+          <Text color="gray">{displaySchubDir}</Text>
+          <Text color="gray">{versionLabel}</Text>
+        </Box>
+      </Box>
+    </Box>
+  );
+}

package/src/changes.ts

@@ -0,0 +1,237 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export type ChangeInfo = {
+  id: string;
+  title: string;
+  status: string;
+  path: string;
+};
+
+const isDirectory = (path: string) => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+const parseProposal = (content: string, changeId: string) => {
+  const titleMatch = content.match(/^#\s+Proposal\s+-\s+(.*)$/m);
+  const statusMatch = content.match(/^\*\*Status\*\*:\s*(.+)$/m);
+
+  return {
+    title: titleMatch?.[1]?.trim() ?? changeId,
+    status: statusMatch?.[1]?.trim() ?? "unknown",
+  };
+};
+
+const changeNumber = (id: string) => {
+  const match = id.match(/\d+/);
+  return match ? Number(match[0]) : Number.POSITIVE_INFINITY;
+};
+
+export const listChanges = (schubDir: string) => {
+  const changesRoot = join(schubDir, "changes");
+  if (!existsSync(changesRoot) || !isDirectory(changesRoot)) {
+    return [];
+  }
+
+  const repoRoot = dirname(schubDir);
+  const entries = readdirSync(changesRoot, { withFileTypes: true });
+  const changes: ChangeInfo[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+
+    const proposalPath = join(changesRoot, entry.name, "proposal.md");
+    if (!existsSync(proposalPath)) {
+      continue;
+    }
+
+    const content = readFileSync(proposalPath, "utf8");
+    const parsed = parseProposal(content, entry.name);
+    changes.push({
+      id: entry.name,
+      title: parsed.title,
+      status: parsed.status,
+      path: relative(repoRoot, proposalPath),
+    });
+  }
+
+  return changes.sort((a, b) => {
+    const numberDiff = changeNumber(a.id) - changeNumber(b.id);
+    if (numberDiff !== 0) {
+      return numberDiff;
+    }
+    return a.id.localeCompare(b.id);
+  });
+};
+
+const slugify = (value: string) => {
+  let slug = value.trim().toLowerCase();
+  slug = slug.replace(/[^a-z0-9]+/g, "-");
+  slug = slug.replace(/-{2,}/g, "-");
+  return slug.replace(/^-|-$/g, "");
+};
+
+const splitPrefixedChangeId = (changeId: string) => {
+  const match = changeId.match(/^([Cc])(\d{3})_([a-z0-9]+(?:-[a-z0-9]+)*)$/);
+  if (match) {
+    return { prefix: match[2], slug: match[3] };
+  }
+  return { prefix: null, slug: changeId };
+};
+
+const nextChangePrefix = (schubDir: string) => {
+  const changesRoot = join(schubDir, "changes");
+  const archiveRoot = join(schubDir, "archive", "changes");
+  const prefixes: number[] = [];
+
+  const scan = (root: string) => {
+    if (!existsSync(root) || !isDirectory(root)) return;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const match = entry.name.match(/^[Cc](\d{3})_/);
+      if (match) {
+        prefixes.push(Number.parseInt(match[1], 10));
+      }
+    }
+  };
+
+  scan(changesRoot);
+  scan(archiveRoot);
+
+  const next = prefixes.length > 0 ? Math.max(...prefixes) + 1 : 1;
+  return next.toString().padStart(3, "0");
+};
+
+const CHANGE_PREFIX = "C";
+
+const PROPOSAL_TEMPLATE_PATH = fileURLToPath(
+  new URL("../templates/create-proposal/proposal-template.md", import.meta.url),
+);
+
+const readProposalTemplate = () => {
+  try {
+    return readFileSync(PROPOSAL_TEMPLATE_PATH, "utf8");
+  } catch {
+    throw new Error(`[ERROR] Template not found: ${PROPOSAL_TEMPLATE_PATH}`);
+  }
+};
+
+const isValidSlug = (value: string) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+
+const changeExists = (schubDir: string, changeId: string) => {
+  const active = join(schubDir, "changes", changeId);
+  if (existsSync(active)) {
+    return true;
+  }
+
+  const archiveRoot = join(schubDir, "archive", "changes");
+  if (!existsSync(archiveRoot) || !isDirectory(archiveRoot)) {
+    return false;
+  }
+
+  for (const entry of readdirSync(archiveRoot, { withFileTypes: true })) {
+    if (entry.isDirectory() && entry.name.includes(changeId)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const resolveChangeRoot = (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;
+  }
+};
+
+export const createChange = (
+  schubDir: string,
+  options: { changeId?: string; title?: string; input?: string; overwrite?: boolean },
+) => {
+  let changeId = (options.changeId || "").trim();
+  let title = (options.title || "").trim();
+  const input = (options.input || "").trim();
+
+  if (!changeId) {
+    if (!title) {
+      throw new Error("Provide --change-id or --title.");
+    }
+    changeId = slugify(title);
+    if (!changeId) {
+      throw new Error("Unable to derive change-id from title.");
+    }
+    console.warn(`[WARN] Derived change-id '${changeId}' from --title. Prefer verb-led ids.`);
+  }
+
+  const originalChangeId = changeId;
+  const { prefix: existingPrefix, slug } = splitPrefixedChangeId(changeId);
+  if (!isValidSlug(slug)) {
+    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case (lowercase letters/digits and hyphens).`);
+  }
+
+  if (!existingPrefix) {
+    const prefix = nextChangePrefix(schubDir);
+    changeId = `${CHANGE_PREFIX}${prefix}_${slug}`;
+    console.error(`[INFO] Prefixed change-id with '${CHANGE_PREFIX}${prefix}_'.`);
+  } else {
+    changeId = `${CHANGE_PREFIX}${existingPrefix}_${slug}`;
+    if (changeId !== originalChangeId) {
+      console.error(`[INFO] Normalized change-id to '${changeId}'.`);
+    }
+  }
+
+  if (!title) {
+    title = slug.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+
+  const changeDir = join(schubDir, "changes", changeId);
+  const proposalPath = join(changeDir, "proposal.md");
+
+  if (changeExists(schubDir, changeId) && !options.overwrite) {
+    throw new Error(`Change '${changeId}' already exists under ${schubDir}. Choose a unique id or pass --overwrite.`);
+  }
+
+  const template = readProposalTemplate();
+  const today = new Date().toISOString().split("T")[0];
+  const rendered = template
+    .replace("{{CHANGE_TITLE}}", title)
+    .replace("{{CHANGE_ID}}", changeId)
+    .replace("{{DATE}}", today)
+    .replace("{{INPUT}}", input || "[no input provided]")
+    .replace("{{AGENT_ROOT}}", schubDir);
+
+  if (existsSync(proposalPath) && !options.overwrite) {
+    throw new Error(`Refusing to overwrite existing file: ${proposalPath}`);
+  }
+
+  mkdirSync(changeDir, { recursive: true });
+  writeFileSync(proposalPath, rendered, "utf8");
+
+  return proposalPath;
+};

package/src/components/PlanView.tsx

@@ -0,0 +1,91 @@
+import { Box, Text } from "ink";
+import React from "react";
+import {
+  buildTaskGraph,
+  findSchubRoot,
+  loadTaskDependencies,
+  renderTaskGraphLines,
+  type TaskStatus,
+  trimTaskTitle,
+} from "../features/tasks";
+
+const PLAN_TASK_STATUSES: readonly TaskStatus[] = ["backlog", "ready", "wip", "blocked"];
+const READY_TASK_STATUSES: readonly TaskStatus[] = ["backlog", "ready"];
+
+export default function PlanView() {
+  const schubDir = React.useMemo(() => findSchubRoot(), []);
+  const planData = React.useMemo(() => {
+    if (!schubDir) {
+      return { visibleTasks: [], readyTasks: [], graphLines: [] };
+    }
+
+    const allTasks = loadTaskDependencies(schubDir);
+    const visibleTasks = allTasks.filter((task) => PLAN_TASK_STATUSES.includes(task.status));
+    const tasksById = new Map(allTasks.map((task) => [task.id, task]));
+    const readyTasks = visibleTasks.filter((task) => {
+      if (!READY_TASK_STATUSES.includes(task.status)) {
+        return false;
+      }
+
+      return task.dependsOn.every((dependencyId) => tasksById.get(dependencyId)?.status === "done");
+    });
+
+    if (visibleTasks.length === 0) {
+      return { visibleTasks, readyTasks, graphLines: [] };
+    }
+
+    const graph = buildTaskGraph(visibleTasks);
+    const graphLines = renderTaskGraphLines(graph);
+    return { visibleTasks, readyTasks, graphLines };
+  }, [schubDir]);
+
+  if (!schubDir) {
+    return (
+      <Box flexDirection="column">
+        <Text color="red">No .schub directory found.</Text>
+      </Box>
+    );
+  }
+
+  if (planData.visibleTasks.length === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text color="gray">No tasks found in .schub</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      <Box flexDirection="column">
+        <Box marginBottom={1}>
+          <Text bold color="white">
+            Ready to Implement
+          </Text>
+        </Box>
+        {planData.readyTasks.length === 0 ? (
+          <Text color="gray">No tasks ready for implementation.</Text>
+        ) : (
+          planData.readyTasks.map((task) => (
+            <Box key={task.id}>
+              <Text color="white">{`${task.id}`}</Text>
+              <Text color="gray"> {trimTaskTitle(task.title)}</Text>
+            </Box>
+          ))
+        )}
+      </Box>
+      <Box flexDirection="column" marginTop={2}>
+        <Box marginBottom={1}>
+          <Text bold color="white">
+            Dependency Plan
+          </Text>
+        </Box>
+        {planData.graphLines.map((line, index) => (
+          <Text key={`${line.text}-${index}`} color={"grey"}>
+            {line.text}
+          </Text>
+        ))}
+      </Box>
+    </Box>
+  );
+}

package/src/components/StatusView.tsx

@@ -0,0 +1,217 @@
+import { Box, Text, useInput } from "ink";
+import React from "react";
+import { type ChangeInfo, listChanges } from "../changes";
+import { findSchubRoot, loadTaskDependencies, type TaskInfo, trimTaskTitle } from "../features/tasks";
+
+type StatusSortable = {
+  id: string;
+  title: string;
+  status: string;
+};
+
+const compareText = (left: string, right: string): number =>
+  left.localeCompare(right, undefined, { sensitivity: "base" });
+
+const sortByStatusThenTitle = (left: StatusSortable, right: StatusSortable): number => {
+  const statusCompare = compareText(left.status, right.status);
+  if (statusCompare !== 0) {
+    return statusCompare;
+  }
+
+  const titleCompare = compareText(left.title, right.title);
+  if (titleCompare !== 0) {
+    return titleCompare;
+  }
+
+  return compareText(left.id, right.id);
+};
+
+export default function StatusView() {
+  const schubDir = React.useMemo(() => findSchubRoot(), []);
+
+  const { pendingReview, pendingImplementation, drafts, blocked, wip, ready, backlog } = React.useMemo(() => {
+    if (!schubDir) {
+      return {
+        pendingReview: [],
+        pendingImplementation: [],
+        drafts: [],
+        blocked: [],
+        wip: [],
+        ready: [],
+        backlog: [],
+      };
+    }
+
+    const allTasks = loadTaskDependencies(schubDir, ["blocked", "wip", "ready", "backlog"]);
+
+    const blockedTasks: TaskInfo[] = [];
+    const wipTasks: TaskInfo[] = [];
+    const readyTasks: TaskInfo[] = [];
+    const backlogTasks: TaskInfo[] = [];
+
+    const activeChangeIds = new Set<string>();
+
+    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.changeId) {
+        activeChangeIds.add(task.changeId);
+      }
+    }
+
+    const allChanges = listChanges(schubDir);
+    const pendingReviewChanges: ChangeInfo[] = [];
+    const pendingImplementationChanges: ChangeInfo[] = [];
+    const draftChanges: ChangeInfo[] = [];
+
+    for (const change of allChanges) {
+      const normalized = change.status.toLowerCase();
+      if (normalized.includes("review")) {
+        pendingReviewChanges.push(change);
+      } else if (
+        activeChangeIds.has(change.id) ||
+        normalized.includes("implementing") ||
+        normalized.includes("accepted")
+      ) {
+        pendingImplementationChanges.push(change);
+      } else if (normalized.includes("draft")) {
+        draftChanges.push(change);
+      }
+    }
+
+    return {
+      pendingReview: pendingReviewChanges.sort(sortByStatusThenTitle),
+      pendingImplementation: pendingImplementationChanges.sort(sortByStatusThenTitle),
+      drafts: draftChanges.sort(sortByStatusThenTitle),
+      blocked: blockedTasks.sort(sortByStatusThenTitle),
+      wip: wipTasks.sort(sortByStatusThenTitle),
+      ready: readyTasks.sort(sortByStatusThenTitle),
+      backlog: backlogTasks.sort(sortByStatusThenTitle),
+    };
+  }, [schubDir]);
+
+  const allItems = React.useMemo(
+    () => [...pendingReview, ...pendingImplementation, ...drafts, ...blocked, ...wip, ...ready, ...backlog],
+    [pendingReview, pendingImplementation, drafts, blocked, wip, ready, backlog],
+  );
+
+  const [selection, setSelection] = React.useState(0);
+  const totalItems = allItems.length;
+
+  React.useEffect(() => {
+    if (totalItems === 0) {
+      setSelection(0);
+      return;
+    }
+    setSelection((current) => Math.min(current, totalItems - 1));
+  }, [totalItems]);
+
+  useInput((_input, key) => {
+    if (totalItems === 0) {
+      return;
+    }
+
+    if (key.downArrow) {
+      setSelection((current) => Math.min(current + 1, totalItems - 1));
+    }
+
+    if (key.upArrow) {
+      setSelection((current) => Math.max(current - 1, 0));
+    }
+  });
+
+  if (!schubDir) {
+    return (
+      <Box flexDirection="column">
+        <Text bold>Status</Text>
+        <Text color="red">No .schub directory found.</Text>
+      </Box>
+    );
+  }
+
+  if (totalItems === 0) {
+    return (
+      <Box flexDirection="column">
+        <Text color="gray">No active changes or tasks found.</Text>
+      </Box>
+    );
+  }
+
+  const renderRow = (item: ChangeInfo | TaskInfo, index: number) => {
+    const selected = index === selection;
+    const isTask = "path" in item && item.path.includes("tasks/");
+    const title = isTask ? trimTaskTitle(item.title) : "";
+
+    return (
+      <Box key={item.id} marginLeft={1}>
+        <Text color={selected ? "blue" : "gray"}>{selected ? "›" : " "}</Text>
+        <Box marginLeft={1}>
+          <Text color="white" bold={selected}>
+            {item.id}
+          </Text>
+          {title ? <Text color="gray"> {title}</Text> : null}
+        </Box>
+      </Box>
+    );
+  };
+
+  let currentIndex = 0;
+
+  const renderSection = (title: string, items: (ChangeInfo | TaskInfo)[]) => {
+    if (items.length === 0) return null;
+
+    const sectionStartIndex = currentIndex;
+    const sectionItems = items.map((item, i) => renderRow(item, sectionStartIndex + i));
+    currentIndex += items.length;
+
+    return (
+      <Box flexDirection="column" marginBottom={1}>
+        <Box marginBottom={0}>
+          <Text color="white">{title}</Text>
+        </Box>
+        {sectionItems}
+      </Box>
+    );
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box flexDirection="column" marginBottom={1}>
+        <Box marginBottom={1}>
+          <Text bold color="white" underline>
+            Change Proposals
+          </Text>
+        </Box>
+        {renderSection("Pending Review", pendingReview)}
+        {renderSection("Pending Implementation", pendingImplementation)}
+        {renderSection("Drafts", drafts)}
+        {pendingReview.length === 0 && pendingImplementation.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>
+            Tasks
+          </Text>
+        </Box>
+        {renderSection("Blocked", blocked)}
+        {renderSection("WIP", wip)}
+        {renderSection("Ready", ready)}
+        {renderSection("Backlog", backlog)}
+        {blocked.length === 0 && wip.length === 0 && ready.length === 0 && backlog.length === 0 && (
+          <Box marginLeft={1}>
+            <Text color="gray">No active tasks.</Text>
+          </Box>
+        )}
+      </Box>
+    </Box>
+  );
+}

package/src/components/statusColor.ts

@@ -0,0 +1 @@
+export const statusColor = (_status?: string): string => "magenta";