@taskmark/ui 0.1.0 → 0.2.1

package/dist/standalone/dist/standalone/lib/taskmark/parse-flat-lists.ts

@@ -1,353 +0,0 @@
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import type {
-  EpicWorkItemsList,
-  FlatWorkItemList,
-  FlatWorkItemRow,
-  ProjectStoriesFlatList,
-  ProjectTasksFlatList,
-  StoryWithEpicRow,
-  TaskWithParentsRow,
-  WorkItemsViewList,
-  WorkItemsViewRow,
-} from "@/lib/taskmark/flat-work-item-types"
-import { compareByStatusThenPriority } from "@/lib/taskmark/list-view-mode"
-import { parseEpicsForProject } from "@/lib/taskmark/parse-epics"
-import { parseItemsForEpic, parseItemsForStory } from "@/lib/taskmark/parse-items"
-import { parseStoriesForEpic } from "@/lib/taskmark/parse-stories"
-
-/**
- * Flat table of every epic, story, and task/bug on the active board.
- */
-export function parseAllWorkItemsForProject(
-  project: DiscoveredProject
-): FlatWorkItemList {
-  const epicList = parseEpicsForProject(project)
-  const rows: FlatWorkItemRow[] = []
-  const errors: FlatWorkItemList["errors"] = epicList.errors.map((e) => ({
-    filePath: e.filePath,
-    message: e.message,
-  }))
-
-  for (const epic of epicList.epics) {
-    rows.push({
-      kind: "epic",
-      id: epic.id,
-      title: epic.title,
-      status: epic.status,
-      priority: epic.priority,
-      size: epic.size,
-      points: epic.points,
-      estimateMinutes: epic.estimateMinutes,
-      actualMinutes: epic.actualMinutes,
-      actualMs: epic.actualMs,
-      epicId: epic.id,
-      epicTitle: epic.title,
-      storyId: null,
-      storyTitle: null,
-      filePath: epic.filePath,
-      project: epic.project,
-    })
-
-    const storyList = parseStoriesForEpic(project, epic.id)
-    for (const err of storyList.errors) {
-      errors.push({ filePath: err.filePath, message: err.message })
-    }
-
-    for (const story of storyList.stories) {
-      rows.push({
-        kind: "story",
-        id: story.id,
-        title: story.title,
-        status: story.status,
-        priority: story.priority,
-        size: story.size,
-        points: story.points,
-        estimateMinutes: story.estimateMinutes,
-        actualMinutes: story.actualMinutes,
-        actualMs: story.actualMs,
-        epicId: epic.id,
-        epicTitle: epic.title,
-        storyId: story.id,
-        storyTitle: story.title,
-        filePath: story.filePath,
-        project: story.project,
-      })
-
-      const items = parseItemsForStory(project, epic.id, story.id)
-      for (const err of items.errors) {
-        errors.push({ filePath: err.filePath, message: err.message })
-      }
-      for (const item of items.items) {
-        rows.push({
-          kind: item.type,
-          id: item.id,
-          title: item.title,
-          status: item.status,
-          priority: item.priority,
-          size: item.size,
-          points: item.points,
-          estimateMinutes: item.estimateMinutes,
-          actualMinutes: item.actualMinutes,
-          actualMs: item.actualMs,
-          epicId: epic.id,
-          epicTitle: epic.title,
-          storyId: story.id,
-          storyTitle: story.title,
-          filePath: item.filePath,
-          project: item.project,
-        })
-      }
-    }
-
-    const epicItems = parseItemsForEpic(project, epic.id)
-    for (const err of epicItems.errors) {
-      errors.push({ filePath: err.filePath, message: err.message })
-    }
-    for (const item of epicItems.items) {
-      rows.push({
-        kind: item.type,
-        id: item.id,
-        title: item.title,
-        status: item.status,
-        priority: item.priority,
-        size: item.size,
-        points: item.points,
-        estimateMinutes: item.estimateMinutes,
-        actualMinutes: item.actualMinutes,
-        actualMs: item.actualMs,
-        epicId: epic.id,
-        epicTitle: epic.title,
-        storyId: null,
-        storyTitle: null,
-        filePath: item.filePath,
-        project: item.project,
-      })
-    }
-  }
-
-  return { project, rows, errors }
-}
-
-/** All stories across every epic, with epic id/title for UI tags. */
-export function parseAllStoriesForProject(
-  project: DiscoveredProject
-): ProjectStoriesFlatList {
-  const epicList = parseEpicsForProject(project)
-  const stories: StoryWithEpicRow[] = []
-  const errors: ProjectStoriesFlatList["errors"] = epicList.errors.map((e) => ({
-    filePath: e.filePath,
-    message: e.message,
-  }))
-
-  for (const epic of epicList.epics) {
-    const storyList = parseStoriesForEpic(project, epic.id)
-    for (const err of storyList.errors) {
-      errors.push({ filePath: err.filePath, message: err.message })
-    }
-    for (const story of storyList.stories) {
-      stories.push({
-        id: story.id,
-        title: story.title,
-        status: story.status,
-        priority: story.priority,
-        size: story.size,
-        points: story.points,
-        estimateMinutes: story.estimateMinutes,
-        actualMinutes: story.actualMinutes,
-        actualMs: story.actualMs,
-        epicId: epic.id,
-        epicTitle: epic.title,
-        workItemCount: story.workItemCount,
-        filePath: story.filePath,
-        project: story.project,
-      })
-    }
-  }
-
-  stories.sort((a, b) => a.id.localeCompare(b.id))
-  return { project, stories, errors }
-}
-
-/** All tasks/bugs across the board, with epic and story UI tags. */
-export function parseAllTasksForProject(
-  project: DiscoveredProject
-): ProjectTasksFlatList {
-  const epicList = parseEpicsForProject(project)
-  const items: TaskWithParentsRow[] = []
-  const errors: ProjectTasksFlatList["errors"] = epicList.errors.map((e) => ({
-    filePath: e.filePath,
-    message: e.message,
-  }))
-
-  for (const epic of epicList.epics) {
-    const storyList = parseStoriesForEpic(project, epic.id)
-    for (const err of storyList.errors) {
-      errors.push({ filePath: err.filePath, message: err.message })
-    }
-
-    for (const story of storyList.stories) {
-      const storyItems = parseItemsForStory(project, epic.id, story.id)
-      for (const err of storyItems.errors) {
-        errors.push({ filePath: err.filePath, message: err.message })
-      }
-      for (const item of storyItems.items) {
-        items.push({
-          id: item.id,
-          type: item.type,
-          title: item.title,
-          status: item.status,
-          priority: item.priority,
-          size: item.size,
-          points: item.points,
-          estimateMinutes: item.estimateMinutes,
-          actualMinutes: item.actualMinutes,
-          actualMs: item.actualMs,
-          epicId: epic.id,
-          epicTitle: epic.title,
-          storyId: story.id,
-          storyTitle: story.title,
-          filePath: item.filePath,
-          project: item.project,
-        })
-      }
-    }
-
-    const epicItems = parseItemsForEpic(project, epic.id)
-    for (const err of epicItems.errors) {
-      errors.push({ filePath: err.filePath, message: err.message })
-    }
-    for (const item of epicItems.items) {
-      items.push({
-        id: item.id,
-        type: item.type,
-        title: item.title,
-        status: item.status,
-        priority: item.priority,
-        size: item.size,
-        points: item.points,
-        estimateMinutes: item.estimateMinutes,
-        actualMinutes: item.actualMinutes,
-        actualMs: item.actualMs,
-        epicId: epic.id,
-        epicTitle: epic.title,
-        storyId: null,
-        storyTitle: null,
-        filePath: item.filePath,
-        project: item.project,
-      })
-    }
-  }
-
-  items.sort((a, b) => a.id.localeCompare(b.id))
-  return { project, items, errors }
-}
-
-/**
- * Overall / Work items: stories + epic-direct tasks/bugs under one epic
- * (excludes tasks/bugs that live under a story). Sorted by status then priority.
- */
-export function parseWorkItemsForEpic(
-  project: DiscoveredProject,
-  epicId: string,
-  epicTitle?: string | null
-): EpicWorkItemsList {
-  const rows: WorkItemsViewRow[] = []
-  const errors: EpicWorkItemsList["errors"] = []
-  const title = epicTitle ?? null
-
-  const storyList = parseStoriesForEpic(project, epicId)
-  for (const err of storyList.errors) {
-    errors.push({ filePath: err.filePath, message: err.message })
-  }
-  const resolvedTitle = title ?? storyList.epicTitle
-  for (const story of storyList.stories) {
-    rows.push({
-      kind: "story",
-      id: story.id,
-      title: story.title,
-      status: story.status,
-      priority: story.priority,
-      size: story.size,
-      points: story.points,
-      estimateMinutes: story.estimateMinutes,
-      actualMinutes: story.actualMinutes,
-      actualMs: story.actualMs,
-      epicId,
-      epicTitle: resolvedTitle ?? epicId,
-      tags: story.tags,
-      reporters: story.reporters,
-      resolvers: story.resolvers,
-      created: story.created,
-      completedAt: story.completedAt,
-      workItemCount: story.workItemCount,
-      doneWorkItemCount: story.doneWorkItemCount,
-      filePath: story.filePath,
-      project: story.project,
-    })
-  }
-
-  const epicItems = parseItemsForEpic(project, epicId)
-  for (const err of epicItems.errors) {
-    errors.push({ filePath: err.filePath, message: err.message })
-  }
-  for (const item of epicItems.items) {
-    rows.push({
-      kind: item.type,
-      id: item.id,
-      title: item.title,
-      status: item.status,
-      priority: item.priority,
-      size: item.size,
-      points: item.points,
-      estimateMinutes: item.estimateMinutes,
-      actualMinutes: item.actualMinutes,
-      actualMs: item.actualMs,
-      epicId,
-      epicTitle: resolvedTitle ?? epicId,
-      tags: item.tags,
-      reporters: item.reporters,
-      resolvers: item.resolvers,
-      created: item.created,
-      completedAt: item.completedAt,
-      workItemCount: 0,
-      doneWorkItemCount: 0,
-      filePath: item.filePath,
-      project: item.project,
-    })
-  }
-
-  rows.sort(compareByStatusThenPriority)
-  return {
-    project,
-    epicId,
-    epicTitle: resolvedTitle,
-    rows,
-    errors,
-  }
-}
-
-/**
- * Work items tab: all stories + epic-direct tasks/bugs only
- * (excludes tasks/bugs that live under a story). Sorted by status then priority.
- */
-export function parseWorkItemsViewForProject(
-  project: DiscoveredProject
-): WorkItemsViewList {
-  const epicList = parseEpicsForProject(project)
-  const rows: WorkItemsViewRow[] = []
-  const errors: WorkItemsViewList["errors"] = epicList.errors.map((e) => ({
-    filePath: e.filePath,
-    message: e.message,
-  }))
-
-  for (const epic of epicList.epics) {
-    const epicWorkItems = parseWorkItemsForEpic(project, epic.id, epic.title)
-    for (const err of epicWorkItems.errors) {
-      errors.push({ filePath: err.filePath, message: err.message })
-    }
-    rows.push(...epicWorkItems.rows)
-  }
-
-  rows.sort(compareByStatusThenPriority)
-  return { project, rows, errors }
-}

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

@@ -1,318 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import type {
-  ItemParseError,
-  ItemSummary,
-  ItemType,
-  StoryItemList,
-} from "@/lib/taskmark/item-types"
-import {
-  asNumberOrNull,
-  asString,
-  asStringArray,
-  extractFrontmatter,
-} from "@/lib/taskmark/frontmatter"
-import { asContributorList } from "@/lib/taskmark/identity"
-import { findEpicFolder } from "@/lib/taskmark/parse-stories"
-import { readTimingFields } from "@/lib/taskmark/timing"
-
-type StoryFolder = {
-  dirName: string
-  storyFile: string
-  id: string
-  title: string
-  epicDirName: string
-}
-
-function readStoryFolderMeta(
-  storyDir: string,
-  dirName: string,
-  epicDirName: string
-): StoryFolder | null {
-  const storyFile = path.join(storyDir, "story.md")
-  if (!fs.existsSync(storyFile)) return null
-
-  let raw: string
-  try {
-    raw = fs.readFileSync(storyFile, "utf8")
-  } catch {
-    return null
-  }
-
-  let frontmatter: Record<string, unknown> | null
-  try {
-    frontmatter = extractFrontmatter(raw)
-  } catch {
-    return null
-  }
-  if (!frontmatter) return null
-
-  const id = asString(frontmatter.id)
-  const title = asString(frontmatter.title)
-  if (!id) return null
-
-  return { dirName, storyFile, id, title, epicDirName }
-}
-
-/** Resolve the story folder under an epic for a given story id. */
-export function findStoryFolder(
-  boardPath: string,
-  epicId: string,
-  storyId: string
-): StoryFolder | null {
-  const epic = findEpicFolder(boardPath, epicId)
-  if (!epic) return null
-
-  const storiesDir = path.join(boardPath, "epics", epic.dirName, "stories")
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(storiesDir, { withFileTypes: true })
-  } catch {
-    return null
-  }
-
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
-    const meta = readStoryFolderMeta(
-      path.join(storiesDir, entry.name),
-      entry.name,
-      epic.dirName
-    )
-    if (meta?.id === storyId) return meta
-  }
-  return null
-}
-
-function listItemMarkdownFiles(itemsParentDir: string): string[] {
-  const itemsDir = path.join(itemsParentDir, "items")
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(itemsDir, { withFileTypes: true })
-  } catch {
-    return []
-  }
-
-  const files: string[] = []
-  for (const entry of entries) {
-    if (!entry.isFile() || entry.name.startsWith(".")) continue
-    if (!entry.name.endsWith(".md")) continue
-    files.push(path.join(itemsDir, entry.name))
-  }
-  return files.sort()
-}
-
-function resolveItemType(
-  frontmatter: Record<string, unknown>,
-  id: string
-): ItemType {
-  const raw = asString(frontmatter.type).toLowerCase()
-  if (raw === "bug") return "bug"
-  if (raw === "task") return "task"
-  if (id.startsWith("B-")) return "bug"
-  return "task"
-}
-
-function parseItemFile(
-  filePath: string,
-  project: DiscoveredProject,
-  parentId: string,
-  epicId: string
-): { item?: ItemSummary; error?: ItemParseError } {
-  let raw: string
-  try {
-    raw = fs.readFileSync(filePath, "utf8")
-  } catch (err) {
-    return {
-      error: {
-        filePath,
-        projectId: project.id,
-        projectName: project.name,
-        storyId: parentId,
-        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,
-        storyId: parentId,
-        message:
-          err instanceof Error ? err.message : "Invalid YAML frontmatter",
-      },
-    }
-  }
-
-  if (!frontmatter) {
-    return {
-      error: {
-        filePath,
-        projectId: project.id,
-        projectName: project.name,
-        storyId: parentId,
-        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,
-        storyId: parentId,
-        message: "Frontmatter requires id and title",
-      },
-    }
-  }
-
-  return {
-    item: {
-      id,
-      type: resolveItemType(frontmatter, 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),
-      parent: asString(frontmatter.parent, parentId),
-      epic: asString(frontmatter.epic, epicId),
-      filePath,
-      project: {
-        id: project.id,
-        name: project.name,
-        projectPath: project.projectPath,
-        boardPath: project.boardPath,
-      },
-    },
-  }
-}
-
-/**
- * Parse all tasks/bugs under a selected story for a project's board root.
- */
-export function parseItemsForStory(
-  project: DiscoveredProject,
-  epicId: string,
-  storyId: string
-): StoryItemList {
-  const folder = findStoryFolder(project.boardPath, epicId, storyId)
-  if (!folder) {
-    const epic = findEpicFolder(project.boardPath, epicId)
-    return {
-      project,
-      epicId,
-      storyId,
-      storyTitle: null,
-      items: [],
-      errors: [
-        {
-          filePath: epic
-            ? path.join(project.boardPath, "epics", epic.dirName, "stories")
-            : path.join(project.boardPath, "epics"),
-          projectId: project.id,
-          projectName: project.name,
-          storyId,
-          message: epic
-            ? `Story ${storyId} not found under epic ${epicId}`
-            : `Epic ${epicId} not found under this board`,
-        },
-      ],
-    }
-  }
-
-  const storyDir = path.join(
-    project.boardPath,
-    "epics",
-    folder.epicDirName,
-    "stories",
-    folder.dirName
-  )
-  const files = listItemMarkdownFiles(storyDir)
-  const items: ItemSummary[] = []
-  const errors: ItemParseError[] = []
-
-  for (const filePath of files) {
-    const result = parseItemFile(filePath, project, storyId, epicId)
-    if (result.item) items.push(result.item)
-    if (result.error) errors.push(result.error)
-  }
-
-  items.sort((a, b) => a.id.localeCompare(b.id))
-
-  return {
-    project,
-    epicId,
-    storyId,
-    storyTitle: folder.title || null,
-    items,
-    errors,
-  }
-}
-
-/**
- * Parse tasks/bugs living directly under an epic (epics/{E}/items/), no story.
- */
-export function parseItemsForEpic(
-  project: DiscoveredProject,
-  epicId: string
-): StoryItemList {
-  const epic = findEpicFolder(project.boardPath, epicId)
-  if (!epic) {
-    return {
-      project,
-      epicId,
-      storyId: epicId,
-      storyTitle: null,
-      items: [],
-      errors: [
-        {
-          filePath: path.join(project.boardPath, "epics"),
-          projectId: project.id,
-          projectName: project.name,
-          storyId: epicId,
-          message: `Epic ${epicId} not found under this board`,
-        },
-      ],
-    }
-  }
-
-  const epicDir = path.join(project.boardPath, "epics", epic.dirName)
-  const files = listItemMarkdownFiles(epicDir)
-  const items: ItemSummary[] = []
-  const errors: ItemParseError[] = []
-
-  for (const filePath of files) {
-    const result = parseItemFile(filePath, project, epicId, epicId)
-    if (result.item) items.push(result.item)
-    if (result.error) errors.push(result.error)
-  }
-
-  items.sort((a, b) => a.id.localeCompare(b.id))
-
-  return {
-    project,
-    epicId,
-    storyId: epicId,
-    storyTitle: "Epic-direct",
-    items,
-    errors,
-  }
-}