@taskmark/ui 0.1.0

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/format-date.ts

@@ -0,0 +1,75 @@
+import { format, isValid, parseISO } from "date-fns"
+
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/
+const EMPTY = new Set(["", "null", "—", "-", "n/a", "N/A"])
+
+/**
+ * Parse Taskmark frontmatter / log date strings.
+ * Date-only values (YYYY-MM-DD) are treated as local calendar days to avoid
+ * UTC midnight shifting the displayed day.
+ */
+export function parseTaskmarkDate(
+  value: string | null | undefined
+): Date | null {
+  const raw = value?.trim() ?? ""
+  if (!raw || EMPTY.has(raw)) return null
+
+  if (DATE_ONLY.test(raw)) {
+    const [y, m, d] = raw.split("-").map(Number)
+    const local = new Date(y, m - 1, d)
+    return isValid(local) ? local : null
+  }
+
+  try {
+    const parsed = parseISO(raw)
+    return isValid(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+function hasTimeComponent(raw: string): boolean {
+  return raw.includes("T") || /\d{2}:\d{2}/.test(raw)
+}
+
+/**
+ * Format any Taskmark date for display.
+ * - Date-only → `Jul 23, 2026`
+ * - Datetime → `Jul 23, 2026, 09:44`
+ * - Missing/invalid → `—`
+ */
+export function formatTaskmarkDate(
+  value: string | null | undefined
+): string {
+  const raw = value?.trim() ?? ""
+  if (!raw || EMPTY.has(raw)) return "—"
+
+  const date = parseTaskmarkDate(raw)
+  if (!date) return raw
+
+  if (hasTimeComponent(raw)) {
+    return format(date, "MMM d, yyyy, HH:mm")
+  }
+  return format(date, "MMM d, yyyy")
+}
+
+/** Always include time when a valid datetime parses; otherwise date-only style. */
+export function formatTaskmarkDateTime(
+  value: string | null | undefined
+): string {
+  const raw = value?.trim() ?? ""
+  if (!raw || EMPTY.has(raw)) return "—"
+
+  const date = parseTaskmarkDate(raw)
+  if (!date) return raw
+
+  if (hasTimeComponent(raw)) {
+    return format(date, "MMM d, yyyy, HH:mm")
+  }
+  return format(date, "MMM d, yyyy")
+}
+
+/** @deprecated Prefer {@link formatTaskmarkDate}. */
+export function formatListDate(value: string | null | undefined): string {
+  return formatTaskmarkDate(value)
+}

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/format-duration.ts

@@ -0,0 +1,72 @@
+/**
+ * Format estimate minutes as a compact human duration.
+ * Examples: `45m`, `2h`, `2h 30m`, `1d`, `1d 4h`
+ */
+export function formatDurationMinutes(value: number | null | undefined): string {
+  if (value === null || value === undefined || !Number.isFinite(value)) {
+    return "—"
+  }
+
+  const total = Math.max(0, Math.round(value))
+  if (total === 0) return "0m"
+
+  return formatDurationMs(total * 60_000)
+}
+
+/**
+ * Format billable Actual from milliseconds.
+ * Uses ms / fractional seconds only when useful; otherwise compact m/h/d.
+ *
+ * Examples: `0ms`, `250ms`, `1.5s`, `45s`, `2m 3s`, `2h 30m`, `1d 4h`
+ */
+export function formatDurationMs(value: number | null | undefined): string {
+  if (value === null || value === undefined || !Number.isFinite(value)) {
+    return "—"
+  }
+
+  const ms = Math.max(0, Math.round(value))
+  if (ms === 0) return "0ms"
+
+  if (ms < 1000) {
+    return `${ms}ms`
+  }
+
+  if (ms < 60_000) {
+    const seconds = ms / 1000
+    if (Number.isInteger(seconds) || ms % 1000 === 0) {
+      return `${Math.round(seconds)}s`
+    }
+    const rounded = Math.round(seconds * 100) / 100
+    return `${rounded}s`
+  }
+
+  const totalSeconds = Math.floor(ms / 1000)
+  const days = Math.floor(totalSeconds / (60 * 60 * 8)) // 1 day ≈ 8h workday
+  let rem = totalSeconds % (60 * 60 * 8)
+  const hours = Math.floor(rem / 3600)
+  rem = rem % 3600
+  const minutes = Math.floor(rem / 60)
+  const seconds = rem % 60
+
+  const parts: string[] = []
+  if (days > 0) parts.push(`${days}d`)
+  if (hours > 0) parts.push(`${hours}h`)
+  if (minutes > 0) parts.push(`${minutes}m`)
+  // Show leftover seconds when under an hour and there is a seconds remainder
+  if (seconds > 0 && days === 0 && hours === 0) {
+    parts.push(`${seconds}s`)
+  }
+
+  return parts.length > 0 ? parts.join(" ") : "0ms"
+}
+
+/** Prefer precise actual_ms; fall back to actual_minutes × 60_000. */
+export function formatActualDuration(
+  actualMs: number | null | undefined,
+  actualMinutes: number | null | undefined
+): string {
+  if (actualMs != null && Number.isFinite(actualMs)) {
+    return formatDurationMs(actualMs)
+  }
+  return formatDurationMinutes(actualMinutes)
+}

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/format-list-date.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `@/lib/format-date` instead. */
+export { formatListDate, formatTaskmarkDate } from "@/lib/format-date"

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/taskmark/active-project.ts

@@ -0,0 +1,16 @@
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+
+/** Resolve which discovered project is active; fall back to the first. */
+export function resolveActiveProject(
+  projects: DiscoveredProject[],
+  activeProjectId: string | null
+): DiscoveredProject | null {
+  if (projects.length === 0) return null
+  if (activeProjectId) {
+    const match = projects.find(
+      (p) => p.id === activeProjectId || p.boardPath === activeProjectId
+    )
+    if (match) return match
+  }
+  return projects[0] ?? null
+}

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

@@ -0,0 +1,118 @@
+import fs from "node:fs"
+import path from "node:path"
+
+import {
+  resolveBoardAtPath,
+  toDiscoveredProject,
+  discoverTaskmarkProjects,
+} from "@/lib/taskmark/discover"
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+
+export type AutoconfigSource = "env_board" | "env_master" | "cwd"
+
+export type AutoconfigWorkspace = {
+  source: AutoconfigSource
+  /** True when the project list is locked to one board (env board or cwd). */
+  singleProject: boolean
+  masters: string[]
+  projects: DiscoveredProject[]
+}
+
+function readEnvPath(name: string): string | null {
+  const raw = process.env[name]
+  if (!raw || !raw.trim()) return null
+  return path.resolve(raw.trim())
+}
+
+function workspaceFromBoard(
+  boardPath: string,
+  source: AutoconfigSource
+): AutoconfigWorkspace {
+  const project = toDiscoveredProject(boardPath)
+  return {
+    source,
+    singleProject: true,
+    masters: [project.projectPath],
+    projects: [project],
+  }
+}
+
+function workspaceFromMaster(
+  masterPath: string,
+  source: AutoconfigSource
+): AutoconfigWorkspace | null {
+  let projects: DiscoveredProject[]
+  try {
+    projects = discoverTaskmarkProjects(masterPath)
+  } catch {
+    return null
+  }
+  if (projects.length === 0) return null
+  return {
+    source,
+    singleProject: projects.length === 1,
+    masters: [path.resolve(masterPath)],
+    projects,
+  }
+}
+
+/**
+ * Candidate directories for cwd-based binding.
+ * Prefers TASKMARK_CWD, then npm's INIT_CWD (where the user invoked npm), then process.cwd().
+ */
+export function cwdCandidates(): string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  for (const raw of [
+    process.env.TASKMARK_CWD,
+    process.env.INIT_CWD,
+    process.cwd(),
+  ]) {
+    if (!raw || !raw.trim()) continue
+    const resolved = path.resolve(raw.trim())
+    try {
+      const key = fs.realpathSync(resolved)
+      if (seen.has(key)) continue
+      seen.add(key)
+      out.push(key)
+    } catch {
+      if (seen.has(resolved)) continue
+      seen.add(resolved)
+      out.push(resolved)
+    }
+  }
+  return out
+}
+
+/**
+ * Resolve a zero-config workspace without cookies.
+ *
+ * Precedence: TASKMARK_BOARD → TASKMARK_MASTER → cwd layouts.
+ * Returns null when nothing valid is found (caller should use cookie setup).
+ */
+export function resolveAutoconfigWorkspace(): AutoconfigWorkspace | null {
+  const boardEnv = readEnvPath("TASKMARK_BOARD")
+  if (boardEnv) {
+    const board = resolveBoardAtPath(boardEnv)
+    if (board) return workspaceFromBoard(board, "env_board")
+    console.warn(
+      `[taskmark] TASKMARK_BOARD is set but is not a valid board path: ${boardEnv}`
+    )
+  }
+
+  const masterEnv = readEnvPath("TASKMARK_MASTER")
+  if (masterEnv) {
+    const fromMaster = workspaceFromMaster(masterEnv, "env_master")
+    if (fromMaster) return fromMaster
+    console.warn(
+      `[taskmark] TASKMARK_MASTER is set but no Taskmark boards were found: ${masterEnv}`
+    )
+  }
+
+  for (const candidate of cwdCandidates()) {
+    const board = resolveBoardAtPath(candidate)
+    if (board) return workspaceFromBoard(board, "cwd")
+  }
+
+  return null
+}

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

@@ -0,0 +1,43 @@
+export const MASTER_FOLDER_COOKIE = "taskmark_master_folder"
+
+/** JSON array of master folder absolute paths (accumulates via Add project) */
+export const MASTER_FOLDERS_COOKIE = "taskmark_master_folders"
+
+/** Active discovered project id (realpath of boardPath) */
+export const ACTIVE_PROJECT_COOKIE = "taskmark_active_project"
+
+/** Cookie lifetime: 1 year */
+export const MASTER_FOLDER_COOKIE_MAX_AGE = 60 * 60 * 24 * 365
+
+export const MASTER_FOLDERS_COOKIE_MAX_AGE = MASTER_FOLDER_COOKIE_MAX_AGE
+
+export const ACTIVE_PROJECT_COOKIE_MAX_AGE = MASTER_FOLDER_COOKIE_MAX_AGE
+
+/** Per-list Hide completed prefs (client-readable; not httpOnly) */
+export const HIDE_COMPLETED_COOKIE_MAX_AGE = MASTER_FOLDER_COOKIE_MAX_AGE
+
+export const HIDE_COMPLETED_COOKIES = {
+  epics: "taskmark_hide_completed_epics",
+  stories: "taskmark_hide_completed_stories",
+  tasks: "taskmark_hide_completed_tasks",
+  overallWorkItems: "taskmark_hide_completed_overall_work_items",
+  workItems: "taskmark_hide_completed_work_items",
+} as const
+
+export type HideCompletedCookieKey = keyof typeof HIDE_COMPLETED_COOKIES
+
+/** How deep to walk under the master folder when discovering boards */
+export const DISCOVERY_MAX_DEPTH = 3
+
+export const DISCOVERY_SKIP_DIR_NAMES = new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".turbo",
+  ".cache",
+  "dist",
+  "build",
+  "coverage",
+  "out",
+  "vendor",
+])

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

@@ -0,0 +1,153 @@
+import { cookies } from "next/headers"
+
+import {
+  ACTIVE_PROJECT_COOKIE,
+  ACTIVE_PROJECT_COOKIE_MAX_AGE,
+  HIDE_COMPLETED_COOKIES,
+  MASTER_FOLDER_COOKIE,
+  MASTER_FOLDERS_COOKIE,
+  MASTER_FOLDERS_COOKIE_MAX_AGE,
+  MASTER_FOLDER_COOKIE_MAX_AGE,
+  type HideCompletedCookieKey,
+} from "@/lib/taskmark/constants"
+import { parseHideCompletedCookieValue } from "@/lib/taskmark/hide-completed-cookie"
+
+async function readEncodedCookie(name: string): Promise<string | null> {
+  const store = await cookies()
+  const value = store.get(name)?.value
+  if (!value) return null
+  try {
+    return decodeURIComponent(value)
+  } catch {
+    return value
+  }
+}
+
+function encodeCookieValue(value: string): string {
+  return encodeURIComponent(value)
+}
+
+/** Legacy single master + new multi-master list. */
+export async function getMasterFoldersCookie(): Promise<string[]> {
+  const rawList = await readEncodedCookie(MASTER_FOLDERS_COOKIE)
+  if (rawList) {
+    try {
+      const parsed = JSON.parse(rawList) as unknown
+      if (Array.isArray(parsed)) {
+        return [
+          ...new Set(
+            parsed
+              .filter((v): v is string => typeof v === "string")
+              .map((v) => v.trim())
+              .filter(Boolean)
+          ),
+        ]
+      }
+    } catch {
+      // fall through to legacy
+    }
+  }
+
+  const legacy = await readEncodedCookie(MASTER_FOLDER_COOKIE)
+  if (legacy?.trim()) {
+    return [legacy.trim()]
+  }
+  return []
+}
+
+export async function setMasterFoldersCookie(masters: string[]): Promise<void> {
+  const unique = [
+    ...new Set(masters.map((m) => m.trim()).filter(Boolean)),
+  ]
+  const store = await cookies()
+  store.set(MASTER_FOLDERS_COOKIE, encodeCookieValue(JSON.stringify(unique)), {
+    path: "/",
+    maxAge: MASTER_FOLDERS_COOKIE_MAX_AGE,
+    sameSite: "lax",
+    httpOnly: true,
+  })
+  // Keep legacy cookie aligned with the latest added master for older readers.
+  if (unique.length > 0) {
+    store.set(MASTER_FOLDER_COOKIE, encodeCookieValue(unique[unique.length - 1]!), {
+      path: "/",
+      maxAge: MASTER_FOLDER_COOKIE_MAX_AGE,
+      sameSite: "lax",
+      httpOnly: true,
+    })
+  } else {
+    store.delete(MASTER_FOLDER_COOKIE)
+  }
+}
+
+export async function addMasterFolderCookie(masterPath: string): Promise<string[]> {
+  const existing = await getMasterFoldersCookie()
+  const next = [...existing]
+  if (!next.includes(masterPath)) {
+    next.push(masterPath)
+  }
+  await setMasterFoldersCookie(next)
+  return next
+}
+
+export async function clearMasterFoldersCookie(): Promise<void> {
+  const store = await cookies()
+  store.delete(MASTER_FOLDERS_COOKIE)
+  store.delete(MASTER_FOLDER_COOKIE)
+}
+
+/** @deprecated use getMasterFoldersCookie */
+export async function getMasterFolderCookie(): Promise<string | null> {
+  const masters = await getMasterFoldersCookie()
+  return masters[masters.length - 1] ?? null
+}
+
+export async function getActiveProjectCookie(): Promise<string | null> {
+  return readEncodedCookie(ACTIVE_PROJECT_COOKIE)
+}
+
+export async function setActiveProjectCookie(projectId: string): Promise<void> {
+  const store = await cookies()
+  store.set(ACTIVE_PROJECT_COOKIE, encodeCookieValue(projectId), {
+    path: "/",
+    maxAge: ACTIVE_PROJECT_COOKIE_MAX_AGE,
+    sameSite: "lax",
+    httpOnly: true,
+  })
+}
+
+export async function clearActiveProjectCookie(): Promise<void> {
+  const store = await cookies()
+  store.delete(ACTIVE_PROJECT_COOKIE)
+}
+
+export async function getHideCompletedCookie(
+  key: HideCompletedCookieKey
+): Promise<boolean> {
+  const store = await cookies()
+  return parseHideCompletedCookieValue(
+    store.get(HIDE_COMPLETED_COOKIES[key])?.value
+  )
+}
+
+export async function getHideCompletedCookies(): Promise<
+  Record<HideCompletedCookieKey, boolean>
+> {
+  const store = await cookies()
+  return {
+    epics: parseHideCompletedCookieValue(
+      store.get(HIDE_COMPLETED_COOKIES.epics)?.value
+    ),
+    stories: parseHideCompletedCookieValue(
+      store.get(HIDE_COMPLETED_COOKIES.stories)?.value
+    ),
+    tasks: parseHideCompletedCookieValue(
+      store.get(HIDE_COMPLETED_COOKIES.tasks)?.value
+    ),
+    overallWorkItems: parseHideCompletedCookieValue(
+      store.get(HIDE_COMPLETED_COOKIES.overallWorkItems)?.value
+    ),
+    workItems: parseHideCompletedCookieValue(
+      store.get(HIDE_COMPLETED_COOKIES.workItems)?.value
+    ),
+  }
+}

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

@@ -0,0 +1,204 @@
+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 }
+}