@taskmark/ui 0.1.0 → 0.2.1

package/dist/standalone/dist/standalone/lib/taskmark/count-leaves.ts

@@ -1,204 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import {
-  asString,
-  extractFrontmatter,
-} from "@/lib/taskmark/frontmatter"
-import { findEpicFolder } from "@/lib/taskmark/parse-stories"
-
-export type ChildProgress = {
-  /** Stories + tasks/bugs (epic) or tasks/bugs (story). */
-  total: number
-  /** Children with status `done`. */
-  done: number
-}
-
-function isLeafMarkdown(filePath: string): boolean {
-  const base = path.basename(filePath)
-  if (!base.endsWith(".md") || base.startsWith(".")) return false
-  // Fast path from filename conventions
-  if (/^[TB]-\d+/i.test(base)) return true
-
-  try {
-    const raw = fs.readFileSync(filePath, "utf8")
-    const fm = extractFrontmatter(raw)
-    if (!fm) return false
-    const type = asString(fm.type).toLowerCase()
-    if (type === "task" || type === "bug") return true
-    const id = asString(fm.id)
-    return id.startsWith("T-") || id.startsWith("B-")
-  } catch {
-    return false
-  }
-}
-
-function isDoneStatus(status: string): boolean {
-  return status.trim().toLowerCase() === "done"
-}
-
-function readStatus(filePath: string): string {
-  try {
-    const raw = fs.readFileSync(filePath, "utf8")
-    const fm = extractFrontmatter(raw)
-    if (!fm) return ""
-    return asString(fm.status)
-  } catch {
-    return ""
-  }
-}
-
-/** Count task/bug markdown files directly under an `items/` directory. */
-export function countLeavesInItemsDir(itemsDir: string): number {
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(itemsDir, { withFileTypes: true })
-  } catch {
-    return 0
-  }
-
-  let count = 0
-  for (const entry of entries) {
-    if (!entry.isFile()) continue
-    const filePath = path.join(itemsDir, entry.name)
-    if (isLeafMarkdown(filePath)) count += 1
-  }
-  return count
-}
-
-function progressLeavesInItemsDir(itemsDir: string): ChildProgress {
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(itemsDir, { withFileTypes: true })
-  } catch {
-    return { total: 0, done: 0 }
-  }
-
-  let total = 0
-  let done = 0
-  for (const entry of entries) {
-    if (!entry.isFile()) continue
-    const filePath = path.join(itemsDir, entry.name)
-    if (!isLeafMarkdown(filePath)) continue
-    total += 1
-    if (isDoneStatus(readStatus(filePath))) done += 1
-  }
-  return { total, done }
-}
-
-function progressStoriesUnderEpic(epicDir: string): ChildProgress {
-  const storiesDir = path.join(epicDir, "stories")
-  let storyEntries: fs.Dirent[]
-  try {
-    storyEntries = fs.readdirSync(storiesDir, { withFileTypes: true })
-  } catch {
-    return { total: 0, done: 0 }
-  }
-
-  let total = 0
-  let done = 0
-  for (const entry of storyEntries) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
-    const storyFile = path.join(storiesDir, entry.name, "story.md")
-    if (!fs.existsSync(storyFile)) continue
-    total += 1
-    if (isDoneStatus(readStatus(storyFile))) done += 1
-  }
-  return { total, done }
-}
-
-function addProgress(a: ChildProgress, b: ChildProgress): ChildProgress {
-  return { total: a.total + b.total, done: a.done + b.done }
-}
-
-/**
- * Work items under an epic: user stories + tasks/bugs in epic `items/`
- * and every story's `items/`.
- */
-export function countWorkItemsUnderEpic(
-  boardPath: string,
-  epicId: string
-): number {
-  return progressUnderEpic(boardPath, epicId).total
-}
-
-/**
- * Progress under an epic: done vs total for stories + epic-direct leaves +
- * all story leaves.
- */
-export function progressUnderEpic(
-  boardPath: string,
-  epicId: string
-): ChildProgress {
-  const epic = findEpicFolder(boardPath, epicId)
-  if (!epic) return { total: 0, done: 0 }
-
-  const epicDir = path.join(boardPath, "epics", epic.dirName)
-  let progress = progressStoriesUnderEpic(epicDir)
-  progress = addProgress(
-    progress,
-    progressLeavesInItemsDir(path.join(epicDir, "items"))
-  )
-
-  const storiesDir = path.join(epicDir, "stories")
-  let storyEntries: fs.Dirent[]
-  try {
-    storyEntries = fs.readdirSync(storiesDir, { withFileTypes: true })
-  } catch {
-    return progress
-  }
-
-  for (const entry of storyEntries) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
-    progress = addProgress(
-      progress,
-      progressLeavesInItemsDir(path.join(storiesDir, entry.name, "items"))
-    )
-  }
-  return progress
-}
-
-/** Work items under a story: tasks + bugs in that story's `items/`. */
-export function countWorkItemsUnderStory(
-  boardPath: string,
-  epicId: string,
-  storyId: string
-): number {
-  return progressUnderStory(boardPath, epicId, storyId).total
-}
-
-/** Progress under a story: done vs total tasks/bugs. */
-export function progressUnderStory(
-  boardPath: string,
-  epicId: string,
-  storyId: string
-): ChildProgress {
-  const epic = findEpicFolder(boardPath, epicId)
-  if (!epic) return { total: 0, done: 0 }
-
-  const storiesDir = path.join(boardPath, "epics", epic.dirName, "stories")
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(storiesDir, { withFileTypes: true })
-  } catch {
-    return { total: 0, done: 0 }
-  }
-
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
-    const storyFile = path.join(storiesDir, entry.name, "story.md")
-    if (!fs.existsSync(storyFile)) continue
-    try {
-      const raw = fs.readFileSync(storyFile, "utf8")
-      const fm = extractFrontmatter(raw)
-      if (!fm) continue
-      if (asString(fm.id) !== storyId) continue
-      return progressLeavesInItemsDir(
-        path.join(storiesDir, entry.name, "items")
-      )
-    } catch {
-      continue
-    }
-  }
-  return { total: 0, done: 0 }
-}

package/dist/standalone/dist/standalone/lib/taskmark/detail-types.ts

@@ -1,131 +0,0 @@
-import type { TimingFields } from "@/lib/taskmark/timing"
-import type { ContributorIdentity } from "@/lib/taskmark/identity"
-
-export type WorkItemKind = "epic" | "story" | "task" | "bug"
-
-export type ChecklistItem = {
-  text: string
-  checked: boolean
-}
-
-export type MarkdownTable = {
-  headers: string[]
-  rows: string[][]
-}
-
-export type PromptFeedbackRow = {
-  index: string
-  when: string
-  kind: string
-  author: string
-  summary: string
-}
-
-export type CommitRow = {
-  sha: string
-  repo: string
-  date: string
-  author: string
-  message: string
-}
-
-export type WorkLogRow = {
-  session: string
-  actor: string
-  started: string
-  ended: string
-  summary: string
-}
-
-export type WorkItemMeta = {
-  id: string
-  title: string
-  type: WorkItemKind
-  status: string
-  priority: string
-  size: string
-  points: number | null
-  estimateMinutes: number | null
-  actualMinutes: number | null
-  actualMs: number | null
-  tags: string[]
-  owner: string
-  reporters: ContributorIdentity[]
-  resolvers: ContributorIdentity[]
-  blocked: boolean
-  cancelled: boolean
-  parent: string
-  epic: string
-  created: string
-  updated: string
-  startedAt: string
-  completedAt: string
-  filePath: string
-}
-
-/** Child row shown on epic/story detail (stories, tasks, bugs). */
-export type DetailChildItem = {
-  id: string
-  title: string
-  type: "story" | "task" | "bug"
-  status: string
-  priority: string
-  filePath: string
-}
-
-export type EpicDetail = WorkItemMeta & {
-  type: "epic"
-  goal: string
-  scope: string
-  outOfScope: string
-  successMetrics: string
-  storiesMarkdown: string
-  /** Stories + epic-direct tasks/bugs under this epic. */
-  children: DetailChildItem[]
-  commits: CommitRow[]
-  workLog: WorkLogRow[]
-}
-
-export type StoryDetail = WorkItemMeta & {
-  type: "story"
-  userStory: string
-  acceptanceCriteria: ChecklistItem[]
-  acceptanceCriteriaRaw: string
-  tasksMarkdown: string
-  /** Tasks/bugs under this story. */
-  children: DetailChildItem[]
-  promptFeedback: PromptFeedbackRow[]
-  commits: CommitRow[]
-  workLog: WorkLogRow[]
-}
-
-export type ItemDetail = WorkItemMeta & {
-  type: "task" | "bug"
-  description: string
-  acceptanceCriteria: ChecklistItem[]
-  acceptanceCriteriaRaw: string
-  reproSteps: string
-  fixCriteria: string
-  notes: string
-  promptFeedback: PromptFeedbackRow[]
-  commits: CommitRow[]
-  workLog: WorkLogRow[]
-}
-
-export type WorkItemDetail = EpicDetail | StoryDetail | ItemDetail
-
-export type WorkItemDetailResult =
-  | { ok: true; detail: WorkItemDetail }
-  | { ok: false; filePath: string; message: string }
-
-export type WorkItemRef = {
-  kind: "epic" | "story" | "item"
-  id: string
-  title: string
-  filePath: string
-  /** Present for tasks/bugs */
-  itemType?: "task" | "bug"
-}
-
-/** Re-export for convenience when building meta */
-export type { TimingFields }

package/dist/standalone/dist/standalone/lib/taskmark/discover.ts

@@ -1,153 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import {
-  DISCOVERY_MAX_DEPTH,
-  DISCOVERY_SKIP_DIR_NAMES,
-} from "@/lib/taskmark/constants"
-import {
-  isDedicatedBoardRepoName,
-  projectNameForBoard,
-  projectPathForBoard,
-  resolveBoardKey,
-} from "@/lib/taskmark/projects"
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-
-function hasBoardMarkers(boardPath: string): boolean {
-  return (
-    fs.existsSync(path.join(boardPath, "INDEX.md")) ||
-    fs.existsSync(path.join(boardPath, "epics"))
-  )
-}
-
-/** Single-project layout: `<project>/taskmark/` with INDEX.md or epics/. */
-export function nestedBoardPath(candidateProjectRoot: string): string | null {
-  const boardPath = path.join(candidateProjectRoot, "taskmark")
-  try {
-    if (!fs.statSync(boardPath).isDirectory()) return null
-  } catch {
-    return null
-  }
-  return hasBoardMarkers(boardPath) ? boardPath : null
-}
-
-/**
- * Multi-project layout: dedicated `<name>-taskmark` repo whose root is the board
- * (INDEX.md / epics/ at the folder root — no nested taskmark/).
- */
-export function flatBoardPath(candidateRoot: string): string | null {
-  if (!isDedicatedBoardRepoName(path.basename(candidateRoot))) return null
-  try {
-    if (!fs.statSync(candidateRoot).isDirectory()) return null
-  } catch {
-    return null
-  }
-  return hasBoardMarkers(candidateRoot) ? candidateRoot : null
-}
-
-/**
- * Resolve a single board directory from a path:
- * - dedicated `*-taskmark` root with markers
- * - nested `<project>/taskmark/` under the path
- * - the path itself when it is already a board directory (e.g. `…/taskmark`)
- */
-export function resolveBoardAtPath(candidatePath: string): string | null {
-  const resolved = path.resolve(candidatePath)
-  try {
-    if (!fs.statSync(resolved).isDirectory()) return null
-  } catch {
-    return null
-  }
-
-  const flat = flatBoardPath(resolved)
-  if (flat) return flat
-
-  const nested = nestedBoardPath(resolved)
-  if (nested) return nested
-
-  // Path is the nested board folder itself (`…/taskmark`) or any board root with markers.
-  if (hasBoardMarkers(resolved)) return resolved
-
-  return null
-}
-
-function resolveDiscoveredBoard(candidateRoot: string): string | null {
-  return flatBoardPath(candidateRoot) ?? nestedBoardPath(candidateRoot)
-}
-
-export function toDiscoveredProject(boardPath: string): DiscoveredProject {
-  const key = resolveBoardKey(boardPath)
-  return {
-    id: key,
-    name: projectNameForBoard(key),
-    projectPath: projectPathForBoard(key),
-    boardPath: key,
-  }
-}
-
-function shouldSkipDir(name: string): boolean {
-  if (DISCOVERY_SKIP_DIR_NAMES.has(name)) return true
-  if (name.startsWith(".")) return true
-  return false
-}
-
-/**
- * Walk a master folder and find Taskmark boards in subfolders.
- *
- * Recognizes:
- * - Single-project: any directory with a nested `taskmark/` board (INDEX.md or epics/)
- * - Multi-project: dedicated `*-taskmark` folders with board files at the repo root
- *
- * Does not require a board at the master root, but includes the master itself if it
- * matches either layout. Dedupes by realpath of the board directory.
- */
-export function discoverTaskmarkProjects(
-  masterPath: string,
-  maxDepth = DISCOVERY_MAX_DEPTH
-): DiscoveredProject[] {
-  const root = path.resolve(masterPath)
-  const found = new Map<string, DiscoveredProject>()
-
-  function visit(dir: string, depth: number) {
-    const board = resolveDiscoveredBoard(dir)
-    if (board) {
-      const project = toDiscoveredProject(board)
-      found.set(project.id, project)
-      // Do not descend into a project's internals looking for nested boards.
-      return
-    }
-
-    if (depth >= maxDepth) return
-
-    let entries: fs.Dirent[]
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true })
-    } catch {
-      return
-    }
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue
-      if (shouldSkipDir(entry.name)) continue
-      if (entry.name === "taskmark") continue
-      visit(path.join(dir, entry.name), depth + 1)
-    }
-  }
-
-  visit(root, 0)
-
-  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name))
-}
-
-/** Discover across many master folders and dedupe identical boards. */
-export function discoverTaskmarkProjectsFromMasters(
-  masterPaths: string[]
-): DiscoveredProject[] {
-  const found = new Map<string, DiscoveredProject>()
-  for (const master of masterPaths) {
-    for (const project of discoverTaskmarkProjects(master)) {
-      found.set(project.id, project)
-    }
-  }
-  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name))
-}

package/dist/standalone/dist/standalone/lib/taskmark/epic-types.ts

@@ -1,41 +0,0 @@
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import type { ContributorIdentity } from "@/lib/taskmark/identity"
-
-export type EpicSummary = {
-  id: string
-  title: string
-  status: string
-  priority: string
-  size: string
-  points: number | null
-  estimateMinutes: number | null
-  actualMinutes: number | null
-  actualMs: number | null
-  tags: string[]
-  reporters: ContributorIdentity[]
-  resolvers: ContributorIdentity[]
-  /** Frontmatter created date (YYYY-MM-DD or ISO). */
-  created: string
-  /** Frontmatter completed_at (ISO) when solved; empty if open. */
-  completedAt: string
-  /** Stories + tasks + bugs under this epic (story children and epic-direct). */
-  workItemCount: number
-  /** Done children among workItemCount (stories + tasks/bugs). */
-  doneWorkItemCount: number
-  /** Absolute path to epic.md */
-  filePath: string
-  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
-}
-
-export type EpicParseError = {
-  filePath: string
-  projectId: string
-  projectName: string
-  message: string
-}
-
-export type ProjectEpicList = {
-  project: DiscoveredProject
-  epics: EpicSummary[]
-  errors: EpicParseError[]
-}

package/dist/standalone/dist/standalone/lib/taskmark/flat-work-item-types.ts

@@ -1,122 +0,0 @@
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import type { ItemType } from "@/lib/taskmark/item-types"
-import type { ContributorIdentity } from "@/lib/taskmark/identity"
-
-export type FlatWorkItemKind = "epic" | "story" | ItemType
-
-export type FlatWorkItemRow = {
-  kind: FlatWorkItemKind
-  id: string
-  title: string
-  status: string
-  priority: string
-  size: string
-  points: number | null
-  estimateMinutes: number | null
-  actualMinutes: number | null
-  actualMs: number | null
-  epicId: string | null
-  epicTitle: string | null
-  storyId: string | null
-  storyTitle: string | null
-  filePath: string
-  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
-}
-
-export type FlatWorkItemList = {
-  project: DiscoveredProject
-  rows: FlatWorkItemRow[]
-  errors: { filePath: string; message: string }[]
-}
-
-export type StoryWithEpicRow = {
-  id: string
-  title: string
-  status: string
-  priority: string
-  size: string
-  points: number | null
-  estimateMinutes: number | null
-  actualMinutes: number | null
-  actualMs: number | null
-  epicId: string
-  epicTitle: string
-  workItemCount: number
-  filePath: string
-  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
-}
-
-export type ProjectStoriesFlatList = {
-  project: DiscoveredProject
-  stories: StoryWithEpicRow[]
-  errors: { filePath: string; message: string }[]
-}
-
-export type TaskWithParentsRow = {
-  id: string
-  type: ItemType
-  title: string
-  status: string
-  priority: string
-  size: string
-  points: number | null
-  estimateMinutes: number | null
-  actualMinutes: number | null
-  actualMs: number | null
-  epicId: string
-  epicTitle: string
-  /** Null when epic-direct (no story). */
-  storyId: string | null
-  storyTitle: string | null
-  filePath: string
-  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
-}
-
-export type ProjectTasksFlatList = {
-  project: DiscoveredProject
-  items: TaskWithParentsRow[]
-  errors: { filePath: string; message: string }[]
-}
-
-/** Work items tab / Overall epic children: story or epic-direct task/bug. */
-export type WorkItemsViewRow = {
-  kind: "story" | ItemType
-  id: string
-  title: string
-  status: string
-  priority: string
-  size: string
-  points: number | null
-  estimateMinutes: number | null
-  actualMinutes: number | null
-  actualMs: number | null
-  epicId: string
-  epicTitle: string
-  tags: string[]
-  reporters: ContributorIdentity[]
-  resolvers: ContributorIdentity[]
-  created: string
-  /** Frontmatter completed_at when solved; empty if open. */
-  completedAt: string
-  /** Child tasks/bugs under a story; 0 for epic-direct leaves. */
-  workItemCount: number
-  /** Done children among workItemCount; 0 for epic-direct leaves. */
-  doneWorkItemCount: number
-  filePath: string
-  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
-}
-
-export type WorkItemsViewList = {
-  project: DiscoveredProject
-  rows: WorkItemsViewRow[]
-  errors: { filePath: string; message: string }[]
-}
-
-/** Overall drill-down: stories + epic-direct items under one epic. */
-export type EpicWorkItemsList = {
-  project: DiscoveredProject
-  epicId: string
-  epicTitle: string | null
-  rows: WorkItemsViewRow[]
-  errors: { filePath: string; message: string }[]
-}

package/dist/standalone/dist/standalone/lib/taskmark/frontmatter.ts

@@ -1,45 +0,0 @@
-import { parse as parseYaml } from "yaml"
-
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/
-
-/**
- * Some board edits historically glued the closing fence onto the last
- * frontmatter line (`completed_at: …Z---`). Normalize before matching.
- */
-export function normalizeFrontmatterSource(raw: string): string {
-  if (!raw.startsWith("---")) return raw
-  return raw.replace(/^(---\r?\n[\s\S]*?\S)---(\r?\n)/, "$1\n---$2")
-}
-
-export function extractFrontmatter(raw: string): Record<string, unknown> | null {
-  const source = normalizeFrontmatterSource(raw)
-  const match = FRONTMATTER_RE.exec(source)
-  if (!match) return null
-  const parsed = parseYaml(match[1])
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return null
-  }
-  return parsed as Record<string, unknown>
-}
-
-export function asString(value: unknown, fallback = ""): string {
-  if (typeof value === "string") return value
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value)
-  }
-  return fallback
-}
-
-export function asNumberOrNull(value: unknown): number | null {
-  if (typeof value === "number" && Number.isFinite(value)) return value
-  if (typeof value === "string" && value.trim() !== "") {
-    const n = Number(value)
-    if (Number.isFinite(n)) return n
-  }
-  return null
-}
-
-export function asStringArray(value: unknown): string[] {
-  if (!Array.isArray(value)) return []
-  return value.map((v) => asString(v)).filter(Boolean)
-}