schub 0.1.0

package/src/features/tasks/constants.ts

@@ -0,0 +1,30 @@
+export const TASK_STATUSES = ["backlog", "ready", "wip", "blocked", "done", "archived"] as const;
+
+export type TaskStatus = (typeof TASK_STATUSES)[number];
+
+export type TaskInfo = {
+  id: string;
+  title: string;
+  status: TaskStatus;
+  path: string;
+  changeId?: string;
+};
+
+export type TaskDependency = TaskInfo & {
+  dependsOn: string[];
+};
+
+export type TaskGraphNode = TaskDependency & {
+  dependencyIds: string[];
+};
+
+export type TaskGraph = {
+  roots: TaskGraphNode[];
+  childrenById: Map<string, TaskGraphNode[]>;
+};
+
+export type TaskGraphLine = {
+  text: string;
+  status: string;
+  isDuplicate: boolean;
+};

package/src/features/tasks/create.ts

@@ -0,0 +1,122 @@
+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 = () => {
+  try {
+    return readFileSync(TASK_TEMPLATE_PATH, "utf8");
+  } catch {
+    throw new Error(`[ERROR] Template not found: ${TASK_TEMPLATE_PATH}`);
+  }
+};
+
+export const createTask = (
+  schubDir: string,
+  options: { changeId: string; status?: string; titles: string[]; overwrite?: boolean },
+) => {
+  const changeId = options.changeId.trim();
+  const status = (options.status || "backlog").trim();
+  const titles = options.titles.map((t) => t.trim()).filter(Boolean);
+
+  // Validate change ID format (simple check)
+  if (!/^(?:[Cc]\d{3}_)?[a-z0-9]+(?:-[a-z0-9]+)*$/.test(changeId)) {
+    throw new Error(`Invalid change-id '${changeId}'. Use kebab-case or a C-prefixed id (e.g., C001_add-user-auth).`);
+  }
+
+  // Normalize change ID (ensure C prefix if it matches pattern)
+  let normalizedChangeId = changeId;
+  const match = changeId.match(/^([Cc])(\d{3})_(.+)$/);
+  if (match) {
+    normalizedChangeId = `C${match[2]}_${match[3]}`;
+  }
+
+  // Validate status
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(status)) {
+    throw new Error(`Invalid status '${status}'. Use kebab-case (lowercase letters/digits and hyphens).`);
+  }
+
+  if (!titles.length) {
+    throw new Error("Provide at least one --title.");
+  }
+
+  // Validate change proposal
+  const changeDir = join(schubDir, "changes", normalizedChangeId);
+  const proposalPath = join(changeDir, "proposal.md");
+
+  if (!existsSync(proposalPath)) {
+    throw new Error(
+      `Required change files missing:\n  - ${proposalPath}\nCreate the change proposal before scaffolding tasks.`,
+    );
+  }
+
+  const content = readFileSync(proposalPath, "utf8");
+  const statusMatch = content.match(/^\*\*Status\*\*:\s*(.+)$/im);
+  const proposalStatus = statusMatch?.[1]?.trim();
+
+  if (!proposalStatus) {
+    throw new Error(
+      `Proposal status not found in ${proposalPath}.\nAdd a '**Status**: Accepted' line before scaffolding tasks.`,
+    );
+  }
+  if (proposalStatus.toLowerCase() !== "accepted") {
+    throw new Error(
+      `Proposal status is '${proposalStatus}' in ${proposalPath}.\nMark the proposal as Accepted before scaffolding tasks.`,
+    );
+  }
+
+  // Find next task number
+  const tasksRoot = join(schubDir, "tasks");
+  const existingNumbers = new Set<number>();
+
+  if (existsSync(tasksRoot)) {
+    const scan = (dir: string) => {
+      if (!existsSync(dir)) return;
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          scan(join(dir, entry.name));
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          const m = entry.name.match(/(?:^|-)T(\d{3})(?:_[^.]+)?\.md$/);
+          if (m) existingNumbers.add(Number.parseInt(m[1], 10));
+        }
+      }
+    };
+    scan(tasksRoot);
+  }
+
+  let nextNumber = existingNumbers.size > 0 ? Math.max(...existingNumbers) + 1 : 1;
+  const statusDir = join(tasksRoot, status);
+  mkdirSync(statusDir, { recursive: true });
+  const template = readTaskTemplate();
+
+  const createdPaths: string[] = [];
+
+  for (const title of titles) {
+    const taskId = `T${nextNumber.toString().padStart(3, "0")}`;
+    let slug = title
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+    if (!slug) slug = "task";
+
+    const filename = `${taskId}_${slug}.md`;
+    const taskPath = join(statusDir, filename);
+
+    const rendered = template
+      .replace("{{TASK_ID}}", taskId)
+      .replace("{{TASK_TITLE}}", title)
+      .replace("{{CHANGE_ID}}", normalizedChangeId);
+
+    if (existsSync(taskPath) && !options.overwrite) {
+      throw new Error(`Refusing to overwrite existing file: ${taskPath}`);
+    }
+
+    writeFileSync(taskPath, rendered, "utf8");
+    createdPaths.push(taskPath);
+    nextNumber++;
+  }
+
+  return createdPaths;
+};

package/src/features/tasks/filesystem.ts

@@ -0,0 +1,178 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { TASK_STATUSES, type TaskDependency, type TaskInfo, type TaskStatus } from "./constants";
+import { compareTaskIds, compareTasks } from "./sorting";
+
+const isDirectory = (path: string): boolean => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+export const findSchubRoot = (startDir: string = process.cwd()): string | null => {
+  let current = resolve(startDir);
+
+  while (true) {
+    const candidate = join(current, ".schub");
+    if (existsSync(candidate) && isDirectory(candidate)) {
+      return candidate;
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+};
+
+const parseTaskFilename = (fileName: string): { id: string; title: string } | null => {
+  if (!fileName.endsWith(".md")) {
+    return null;
+  }
+
+  const baseName = fileName.slice(0, -3);
+  const underscoreIndex = baseName.indexOf("_");
+  if (underscoreIndex <= 0) {
+    return null;
+  }
+
+  const id = baseName.slice(0, underscoreIndex);
+  const titleSlug = baseName.slice(underscoreIndex + 1);
+  return { id, title: titleSlug.replace(/-/g, " ") };
+};
+
+type ParsedTaskFile = {
+  id: string;
+  title: string;
+  dependsOn: string[];
+  changeId?: string;
+};
+
+const parseTaskFile = (filePath: string, fallback: { id: string; title: string }): ParsedTaskFile => {
+  let content = "";
+  try {
+    content = readFileSync(filePath, "utf8");
+  } catch {
+    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();
+
+  const dependsMatch = content.match(/^\*\*Depends on\*\*:\s*(.+)$/m);
+  let dependsOn: string[] = [];
+  if (dependsMatch) {
+    const raw = dependsMatch[1].trim();
+    if (!/^none$/i.test(raw)) {
+      const matches = raw.match(/\bT\d+\b/g);
+      if (matches) {
+        dependsOn = Array.from(new Set(matches));
+      }
+    }
+  }
+
+  return { id, title, dependsOn, changeId };
+};
+
+export const listTasks = (schubDir: string, statuses: readonly TaskStatus[] = TASK_STATUSES): TaskInfo[] => {
+  const tasksRoot = join(schubDir, "tasks");
+  if (!existsSync(tasksRoot) || !isDirectory(tasksRoot)) {
+    return [];
+  }
+
+  const allowed = new Set(statuses);
+  const repoRoot = dirname(schubDir);
+  const tasks: TaskInfo[] = [];
+
+  for (const status of TASK_STATUSES) {
+    if (!allowed.has(status)) {
+      continue;
+    }
+
+    const statusDir = join(tasksRoot, status);
+    if (!existsSync(statusDir) || !isDirectory(statusDir)) {
+      continue;
+    }
+
+    const entries = readdirSync(statusDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      const parsed = parseTaskFilename(entry.name);
+      if (!parsed) {
+        continue;
+      }
+
+      const filePath = join(statusDir, entry.name);
+      tasks.push({
+        id: parsed.id,
+        title: parsed.title,
+        status,
+        path: relative(repoRoot, filePath),
+      });
+    }
+  }
+
+  return tasks.sort(compareTasks);
+};
+
+export const loadTaskDependencies = (
+  schubDir: string,
+  statuses: readonly TaskStatus[] = TASK_STATUSES,
+): TaskDependency[] => {
+  const tasksRoot = join(schubDir, "tasks");
+  if (!existsSync(tasksRoot) || !isDirectory(tasksRoot)) {
+    return [];
+  }
+
+  const allowed = new Set(statuses);
+  const repoRoot = dirname(schubDir);
+  const tasks: TaskDependency[] = [];
+
+  for (const status of TASK_STATUSES) {
+    if (!allowed.has(status)) {
+      continue;
+    }
+
+    const statusDir = join(tasksRoot, status);
+    if (!existsSync(statusDir) || !isDirectory(statusDir)) {
+      continue;
+    }
+
+    const entries = readdirSync(statusDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      const parsed = parseTaskFilename(entry.name);
+      if (!parsed) {
+        continue;
+      }
+
+      const filePath = join(statusDir, entry.name);
+      const parsedFile = parseTaskFile(filePath, parsed);
+      const dependsOn = parsedFile.dependsOn.sort(compareTaskIds);
+
+      tasks.push({
+        id: parsedFile.id,
+        title: parsedFile.title,
+        status,
+        path: relative(repoRoot, filePath),
+        dependsOn,
+        changeId: parsedFile.changeId,
+      });
+    }
+  }
+
+  return tasks.sort(compareTasks);
+};

package/src/features/tasks/graph.ts

@@ -0,0 +1,87 @@
+import type { TaskDependency, TaskGraph, TaskGraphLine, TaskGraphNode } from "./constants";
+import { compareTaskIds, compareTasks } from "./sorting";
+
+export const buildTaskGraph = (tasks: TaskDependency[]): TaskGraph => {
+  const tasksById = new Map(tasks.map((task) => [task.id, task]));
+  const nodes = new Map<string, TaskGraphNode>();
+
+  for (const task of tasks) {
+    const uniqueDependencies = Array.from(new Set(task.dependsOn)).sort(compareTaskIds);
+    const dependencyIds = uniqueDependencies.filter((dependency) => tasksById.has(dependency));
+
+    nodes.set(task.id, {
+      ...task,
+      dependencyIds,
+    });
+  }
+
+  const childrenById = new Map<string, TaskGraphNode[]>();
+  for (const node of nodes.values()) {
+    for (const dependencyId of node.dependencyIds) {
+      const siblings = childrenById.get(dependencyId) ?? [];
+      siblings.push(node);
+      childrenById.set(dependencyId, siblings);
+    }
+  }
+
+  for (const [id, children] of childrenById) {
+    childrenById.set(id, children.sort(compareTasks));
+  }
+
+  const roots = Array.from(nodes.values())
+    .filter((node) => node.dependencyIds.length === 0)
+    .sort(compareTasks);
+
+  return { roots, childrenById };
+};
+
+export const trimTaskTitle = (title: string, maxLength: number = 40): string => {
+  const trimmed = title.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+
+  if (maxLength <= 1) {
+    return "…";
+  }
+
+  return `${trimmed.slice(0, maxLength - 1).trimEnd()}…`;
+};
+
+export const renderTaskGraphLines = (graph: TaskGraph): TaskGraphLine[] => {
+  const lines: TaskGraphLine[] = [];
+  const renderedIds = new Set<string>();
+
+  const renderNode = (node: TaskGraphNode, prefix: string, isLast: boolean, isRoot: boolean) => {
+    const connector = isRoot ? "" : isLast ? "└─ " : "├─ ";
+
+    if (renderedIds.has(node.id)) {
+      lines.push({
+        text: `${prefix}${connector}${node.id} ↩`,
+        status: node.status,
+        isDuplicate: true,
+      });
+      return;
+    }
+
+    renderedIds.add(node.id);
+    const title = trimTaskTitle(node.title);
+    lines.push({
+      text: `${prefix}${connector}${node.id} ${title}`,
+      status: node.status,
+      isDuplicate: false,
+    });
+
+    const children = graph.childrenById.get(node.id) ?? [];
+    const nextPrefix = isRoot ? `${prefix}   ` : `${prefix}${isLast ? "   " : "│  "}`;
+    children.forEach((child, index) => {
+      renderNode(child, nextPrefix, index === children.length - 1, false);
+    });
+  };
+
+  graph.roots.forEach((root, index) => {
+    renderNode(root, "", index === graph.roots.length - 1, true);
+  });
+
+  return lines;
+};

package/src/features/tasks/index.ts

@@ -0,0 +1,12 @@
+export {
+  TASK_STATUSES,
+  type TaskDependency,
+  type TaskGraph,
+  type TaskGraphLine,
+  type TaskGraphNode,
+  type TaskInfo,
+  type TaskStatus,
+} from "./constants";
+export { createTask } from "./create";
+export { findSchubRoot, listTasks, loadTaskDependencies } from "./filesystem";
+export { buildTaskGraph, renderTaskGraphLines, trimTaskTitle } from "./graph";

package/src/features/tasks/sorting.ts

@@ -0,0 +1,14 @@
+const taskNumber = (id: string): number => {
+  const match = id.match(/\d+/);
+  return match ? Number(match[0]) : Number.POSITIVE_INFINITY;
+};
+
+export const compareTaskIds = (left: string, right: string): number => {
+  const numberDiff = taskNumber(left) - taskNumber(right);
+  if (numberDiff !== 0) {
+    return numberDiff;
+  }
+  return left.localeCompare(right);
+};
+
+export const compareTasks = (left: { id: string }, right: { id: string }): number => compareTaskIds(left.id, right.id);