@taskmark/ui 0.1.0 → 0.2.1

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/taskmark/list-view-mode.ts

@@ -1,137 +0,0 @@
-export const LIST_VIEW_MODES = ["overall", "workitems"] as const
-
-export type ListViewMode = (typeof LIST_VIEW_MODES)[number]
-
-export const DEFAULT_LIST_VIEW_MODE: ListViewMode = "overall"
-
-export const LIST_VIEW_LABELS: Record<ListViewMode, string> = {
-  overall: "Overall",
-  workitems: "Work items",
-}
-
-/** Legacy view query values that map to Work items. */
-const LEGACY_WORKITEMS_VIEWS = new Set(["all", "stories", "tasks", "workitems"])
-
-export function parseListViewMode(
-  value: string | string[] | undefined
-): ListViewMode {
-  const raw = typeof value === "string" ? value.trim().toLowerCase() : ""
-  if (raw === "overall") return "overall"
-  if (LEGACY_WORKITEMS_VIEWS.has(raw)) return "workitems"
-  return DEFAULT_LIST_VIEW_MODE
-}
-
-export function boardHref(opts: {
-  view?: ListViewMode
-  epic?: string | null
-  story?: string | null
-  /** Open work item detail sheet (E-/S-/T-/B- id). */
-  item?: string | null
-}): string {
-  const params = new URLSearchParams()
-  const view = opts.view ?? DEFAULT_LIST_VIEW_MODE
-  if (view !== DEFAULT_LIST_VIEW_MODE) {
-    params.set("view", view)
-  }
-  if (view === "overall") {
-    if (opts.epic) params.set("epic", opts.epic)
-    if (opts.epic && opts.story) params.set("story", opts.story)
-  }
-  if (opts.item) params.set("item", opts.item)
-  const qs = params.toString()
-  return qs ? `/board?${qs}` : "/board"
-}
-
-const STATUS_RANK: Record<string, number> = {
-  backlog: 0,
-  in_progress: 1,
-  done: 2,
-  blocked: 3,
-  cancelled: 4,
-}
-
-const PRIORITY_RANK: Record<string, number> = {
-  critical: 0,
-  high: 1,
-  medium: 2,
-  low: 3,
-}
-
-export function statusSortRank(status: string): number {
-  return STATUS_RANK[status.toLowerCase()] ?? 50
-}
-
-export function prioritySortRank(priority: string): number {
-  return PRIORITY_RANK[priority.toLowerCase()] ?? 50
-}
-
-/**
- * Primary: status (backlog → in_progress → done);
- * For open statuses: priority (highest first), then created (newest first);
- * For done/cancelled: solved date only (completedAt newest first; no priority);
- * then id.
- */
-export function compareByStatusThenPriority(
-  a: {
-    status: string
-    priority: string
-    created?: string
-    completedAt?: string
-    id: string
-  },
-  b: {
-    status: string
-    priority: string
-    created?: string
-    completedAt?: string
-    id: string
-  }
-): number {
-  const byStatus = statusSortRank(a.status) - statusSortRank(b.status)
-  if (byStatus !== 0) return byStatus
-
-  // Solved cohort: newest completed first; ignore priority.
-  if (usesCompletedDate(a.status)) {
-    return compareByDateThenId(a, b, /*preferCompleted*/ true)
-  }
-
-  const byPriority =
-    prioritySortRank(a.priority) - prioritySortRank(b.priority)
-  if (byPriority !== 0) return byPriority
-
-  return compareByDateThenId(a, b, /*preferCompleted*/ false)
-}
-
-function usesCompletedDate(status: string): boolean {
-  const s = status.trim().toLowerCase()
-  return s === "done" || s === "cancelled"
-}
-
-function compareByDateThenId(
-  a: { created?: string; completedAt?: string; id: string; status: string },
-  b: { created?: string; completedAt?: string; id: string; status: string },
-  preferCompleted: boolean
-): number {
-  const dateA = preferCompleted
-    ? completedOrCreated(a)
-    : (a.created?.trim() ?? "")
-  const dateB = preferCompleted
-    ? completedOrCreated(b)
-    : (b.created?.trim() ?? "")
-  if (dateA && dateB) {
-    const byDate = dateB.localeCompare(dateA)
-    if (byDate !== 0) return byDate
-  } else if (dateA !== dateB) {
-    return dateA ? -1 : 1
-  }
-  return a.id.localeCompare(b.id)
-}
-
-function completedOrCreated(row: {
-  created?: string
-  completedAt?: string
-}): string {
-  const done = row.completedAt?.trim() ?? ""
-  if (done) return done
-  return row.created?.trim() ?? ""
-}

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

@@ -1,51 +0,0 @@
-/** Shared list pagination types and defaults (1-based page index). */
-
-export const PAGE_SIZE_OPTIONS = [10, 25, 50, 100] as const
-
-export type PageSize = (typeof PAGE_SIZE_OPTIONS)[number]
-
-export const DEFAULT_PAGE_SIZE: PageSize = 25
-
-export type PaginationState = {
-  /** 1-based page index. */
-  page: number
-  pageSize: PageSize
-}
-
-export type PageSliceResult<T> = {
-  pageRows: T[]
-  totalCount: number
-  /** 0 when there are no rows; otherwise ≥ 1. */
-  totalPages: number
-  /** Clamped 1-based page. */
-  page: number
-  pageSize: PageSize
-}
-
-export function isPageSize(value: number): value is PageSize {
-  return (PAGE_SIZE_OPTIONS as readonly number[]).includes(value)
-}
-
-/**
- * Slice `rows` for the given 1-based `page` and `pageSize`.
- * Empty input → totalPages 0, page 1, empty pageRows.
- */
-export function slicePage<T>(
-  rows: readonly T[],
-  page: number,
-  pageSize: number
-): PageSliceResult<T> {
-  const size: PageSize = isPageSize(pageSize) ? pageSize : DEFAULT_PAGE_SIZE
-  const totalCount = rows.length
-  const totalPages = totalCount === 0 ? 0 : Math.ceil(totalCount / size)
-  const clampedPage =
-    totalPages === 0 ? 1 : Math.min(Math.max(1, Math.trunc(page) || 1), totalPages)
-  const start = (clampedPage - 1) * size
-  return {
-    pageRows: rows.slice(start, start + size) as T[],
-    totalCount,
-    totalPages,
-    page: clampedPage,
-    pageSize: size,
-  }
-}

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

@@ -1,227 +0,0 @@
-import {
-  asNumberOrNull,
-  asString,
-  asStringArray,
-  extractFrontmatter,
-} from "@/lib/taskmark/frontmatter"
-import { asContributorList } from "@/lib/taskmark/identity"
-import { readTimingFields } from "@/lib/taskmark/timing"
-import type {
-  CommitRow,
-  EpicDetail,
-  ItemDetail,
-  PromptFeedbackRow,
-  StoryDetail,
-  WorkItemDetailResult,
-  WorkItemKind,
-  WorkItemMeta,
-  WorkLogRow,
-} from "@/lib/taskmark/detail-types"
-import {
-  cell,
-  extractMarkdownBody,
-  extractSections,
-  getSection,
-  parseChecklist,
-  parseMarkdownTable,
-  tableRowsAsObjects,
-} from "@/lib/taskmark/parse-sections"
-
-function asBool(value: unknown): boolean {
-  if (typeof value === "boolean") return value
-  if (typeof value === "string") return value.toLowerCase() === "true"
-  return false
-}
-
-function parseCommits(section: string): CommitRow[] {
-  const rows = tableRowsAsObjects(parseMarkdownTable(section))
-  return rows.map((row) => ({
-    sha: cell(row, "sha"),
-    repo: cell(row, "repo"),
-    date: cell(row, "date (utc)", "date"),
-    author: cell(row, "author"),
-    message: cell(row, "message"),
-  }))
-}
-
-function parseWorkLog(section: string): WorkLogRow[] {
-  const rows = tableRowsAsObjects(parseMarkdownTable(section))
-  return rows.map((row) => ({
-    session: cell(row, "session"),
-    actor: cell(row, "actor"),
-    started: cell(row, "started (utc)", "started"),
-    ended: cell(row, "ended (utc)", "ended"),
-    summary: cell(row, "summary"),
-  }))
-}
-
-function parsePromptFeedback(section: string): PromptFeedbackRow[] {
-  const rows = tableRowsAsObjects(parseMarkdownTable(section))
-  return rows.map((row) => ({
-    index: cell(row, "#", "index"),
-    when: cell(row, "when (utc)", "when"),
-    kind: cell(row, "kind"),
-    author: cell(row, "author"),
-    summary: cell(row, "summary"),
-  }))
-}
-
-function resolveKind(
-  frontmatter: Record<string, unknown>,
-  id: string,
-  hint?: "epic" | "story" | "item"
-): WorkItemKind {
-  const typed = asString(frontmatter.type).toLowerCase()
-  if (typed === "epic" || typed === "story" || typed === "task" || typed === "bug") {
-    return typed
-  }
-  if (hint === "epic") return "epic"
-  if (hint === "story") return "story"
-  if (id.startsWith("B-")) return "bug"
-  if (id.startsWith("E-")) return "epic"
-  if (id.startsWith("S-")) return "story"
-  return "task"
-}
-
-function buildMeta(
-  frontmatter: Record<string, unknown>,
-  filePath: string,
-  kind: WorkItemKind
-): WorkItemMeta | null {
-  const id = asString(frontmatter.id)
-  const title = asString(frontmatter.title)
-  if (!id || !title) return null
-
-  const timing = readTimingFields(frontmatter)
-  return {
-    id,
-    title,
-    type: kind,
-    status: asString(frontmatter.status, "unknown"),
-    priority: asString(frontmatter.priority, "medium"),
-    size: asString(frontmatter.size, "—"),
-    points: asNumberOrNull(frontmatter.points),
-    estimateMinutes: timing.estimateMinutes,
-    actualMinutes: timing.actualMinutes,
-    actualMs: timing.actualMs,
-    tags: asStringArray(frontmatter.tags),
-    owner: asString(frontmatter.owner),
-    reporters: asContributorList(frontmatter.reporters),
-    resolvers: asContributorList(frontmatter.resolvers),
-    blocked: asBool(frontmatter.blocked),
-    cancelled: asBool(frontmatter.cancelled),
-    parent: asString(frontmatter.parent),
-    epic: asString(frontmatter.epic),
-    created: asString(frontmatter.created),
-    updated: asString(frontmatter.updated),
-    startedAt: asString(frontmatter.started_at),
-    completedAt: asString(frontmatter.completed_at),
-    filePath,
-  }
-}
-
-export function parseWorkItemDetailFromRaw(
-  raw: string,
-  filePath: string,
-  hint?: "epic" | "story" | "item"
-): WorkItemDetailResult {
-  let frontmatter: Record<string, unknown> | null
-  try {
-    frontmatter = extractFrontmatter(raw)
-  } catch (err) {
-    return {
-      ok: false,
-      filePath,
-      message:
-        err instanceof Error ? err.message : "Invalid YAML frontmatter",
-    }
-  }
-
-  if (!frontmatter) {
-    return {
-      ok: false,
-      filePath,
-      message: "Missing or invalid YAML frontmatter",
-    }
-  }
-
-  const id = asString(frontmatter.id)
-  const kind = resolveKind(frontmatter, id, hint)
-  const meta = buildMeta(frontmatter, filePath, kind)
-  if (!meta) {
-    return {
-      ok: false,
-      filePath,
-      message: "Frontmatter requires id and title",
-    }
-  }
-
-  const body = extractMarkdownBody(raw)
-  const sections = extractSections(body)
-
-  if (kind === "epic") {
-    const detail: EpicDetail = {
-      ...meta,
-      type: "epic",
-      goal: getSection(sections, "Goal"),
-      scope: getSection(sections, "Scope"),
-      outOfScope: getSection(sections, "Out of scope"),
-      successMetrics: getSection(sections, "Success metrics"),
-      storiesMarkdown: getSection(sections, "Stories"),
-      children: [],
-      commits: parseCommits(getSection(sections, "Commits")),
-      workLog: parseWorkLog(getSection(sections, "Work log")),
-    }
-    return { ok: true, detail }
-  }
-
-  if (kind === "story") {
-    const acRaw = getSection(sections, "Acceptance criteria")
-    const detail: StoryDetail = {
-      ...meta,
-      type: "story",
-      userStory: getSection(sections, "User story"),
-      acceptanceCriteria: parseChecklist(acRaw),
-      acceptanceCriteriaRaw: acRaw,
-      tasksMarkdown: getSection(sections, "Tasks"),
-      children: [],
-      promptFeedback: parsePromptFeedback(
-        getSection(sections, "Prompt & feedback log", "Prompt & feedback")
-      ),
-      commits: parseCommits(getSection(sections, "Commits")),
-      workLog: parseWorkLog(getSection(sections, "Work log")),
-    }
-    return { ok: true, detail }
-  }
-
-  const detail: ItemDetail = {
-    ...meta,
-    type: kind === "bug" ? "bug" : "task",
-    description: getSection(sections, "Description"),
-    acceptanceCriteria:
-      kind === "bug" ? [] : parseChecklist(getSection(sections, "Acceptance criteria")),
-    acceptanceCriteriaRaw:
-      kind === "bug" ? "" : getSection(sections, "Acceptance criteria"),
-    reproSteps: kind === "bug" ? getSection(sections, "Repro steps") : "",
-    fixCriteria: kind === "bug" ? getSection(sections, "Fix criteria") : "",
-    notes: getSection(sections, "Notes"),
-    promptFeedback: parsePromptFeedback(
-      getSection(sections, "Prompt & feedback log", "Prompt & feedback")
-    ),
-    commits: parseCommits(getSection(sections, "Commits")),
-    workLog: parseWorkLog(getSection(sections, "Work log")),
-  }
-
-  // For bugs, also try parsing fix criteria as checklist when checkbox-shaped
-  if (kind === "bug") {
-    const fixRaw = getSection(sections, "Fix criteria")
-    detail.fixCriteria = fixRaw
-    const fixChecks = parseChecklist(fixRaw)
-    if (fixChecks.length > 0) {
-      detail.acceptanceCriteria = fixChecks
-      detail.acceptanceCriteriaRaw = fixRaw
-    }
-  }
-
-  return { ok: true, detail }
-}

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/taskmark/parse-epics.ts

@@ -1,153 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import type {
-  EpicParseError,
-  EpicSummary,
-  ProjectEpicList,
-} from "@/lib/taskmark/epic-types"
-import {
-  asNumberOrNull,
-  asString,
-  asStringArray,
-  extractFrontmatter,
-} from "@/lib/taskmark/frontmatter"
-import { asContributorList } from "@/lib/taskmark/identity"
-import { readTimingFields } from "@/lib/taskmark/timing"
-import { sortEpicsGeneralFirst } from "@/lib/taskmark/general-epic"
-import { progressUnderEpic } from "@/lib/taskmark/count-leaves"
-
-function listEpicMarkdownFiles(boardPath: string): string[] {
-  const epicsDir = path.join(boardPath, "epics")
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(epicsDir, { withFileTypes: true })
-  } catch {
-    return []
-  }
-
-  const files: string[] = []
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
-    if (entry.name.startsWith(".")) continue
-    const epicFile = path.join(epicsDir, entry.name, "epic.md")
-    if (fs.existsSync(epicFile)) {
-      files.push(epicFile)
-    }
-  }
-  return files.sort()
-}
-
-function parseEpicFile(
-  filePath: string,
-  project: DiscoveredProject
-): { epic?: EpicSummary; error?: EpicParseError } {
-  let raw: string
-  try {
-    raw = fs.readFileSync(filePath, "utf8")
-  } catch (err) {
-    return {
-      error: {
-        filePath,
-        projectId: project.id,
-        projectName: project.name,
-        message: err instanceof Error ? err.message : "Failed to read file",
-      },
-    }
-  }
-
-  let frontmatter: Record<string, unknown> | null
-  try {
-    frontmatter = extractFrontmatter(raw)
-  } catch (err) {
-    return {
-      error: {
-        filePath,
-        projectId: project.id,
-        projectName: project.name,
-        message:
-          err instanceof Error ? err.message : "Invalid YAML frontmatter",
-      },
-    }
-  }
-
-  if (!frontmatter) {
-    return {
-      error: {
-        filePath,
-        projectId: project.id,
-        projectName: project.name,
-        message: "Missing or invalid YAML frontmatter",
-      },
-    }
-  }
-
-  const id = asString(frontmatter.id)
-  const title = asString(frontmatter.title)
-  if (!id || !title) {
-    return {
-      error: {
-        filePath,
-        projectId: project.id,
-        projectName: project.name,
-        message: "Frontmatter requires id and title",
-      },
-    }
-  }
-
-  const progress = progressUnderEpic(project.boardPath, id)
-
-  return {
-    epic: {
-      id,
-      title,
-      status: asString(frontmatter.status, "unknown"),
-      priority: asString(frontmatter.priority, "medium"),
-      size: asString(frontmatter.size, "—"),
-      points: asNumberOrNull(frontmatter.points),
-      ...readTimingFields(frontmatter),
-      tags: asStringArray(frontmatter.tags),
-      reporters: asContributorList(frontmatter.reporters),
-      resolvers: asContributorList(frontmatter.resolvers),
-      created: asString(frontmatter.created),
-      completedAt: asString(frontmatter.completed_at),
-      workItemCount: progress.total,
-      doneWorkItemCount: progress.done,
-      filePath,
-      project: {
-        id: project.id,
-        name: project.name,
-        projectPath: project.projectPath,
-        boardPath: project.boardPath,
-      },
-    },
-  }
-}
-
-/** Parse all epics under a project's board root (nested taskmark/ or flat *-taskmark). */
-export function parseEpicsForProject(
-  project: DiscoveredProject
-): ProjectEpicList {
-  const files = listEpicMarkdownFiles(project.boardPath)
-  const epics: EpicSummary[] = []
-  const errors: EpicParseError[] = []
-
-  for (const filePath of files) {
-    const result = parseEpicFile(filePath, project)
-    if (result.epic) epics.push(result.epic)
-    if (result.error) errors.push(result.error)
-  }
-
-  epics.sort((a, b) => a.id.localeCompare(b.id))
-  const ordered = sortEpicsGeneralFirst(epics)
-
-  return { project, epics: ordered, errors }
-}
-
-/** Parse epics for every discovered project under the master folder. */
-export function parseEpicsForProjects(
-  projects: DiscoveredProject[]
-): ProjectEpicList[] {
-  return projects.map(parseEpicsForProject)
-}