@taskmark/ui 0.1.0 → 0.2.0

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

@@ -1,296 +0,0 @@
-/**
- * Project status metrics for the board overview (E-015).
- * Counts stories/tasks/bugs; Current Speed = 90-day weekly points average.
- */
-
-import { addDays } from "date-fns"
-
-import type { ContributorIdentity } from "@/lib/taskmark/identity"
-import { parseEpicsForProject } from "@/lib/taskmark/parse-epics"
-import { parseItemsForEpic, parseItemsForStory } from "@/lib/taskmark/parse-items"
-import { parseStoriesForEpic } from "@/lib/taskmark/parse-stories"
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import { parseTaskmarkDate } from "@/lib/format-date"
-import {
-  isoWeekCountKey,
-  isoWeekParts,
-  shiftIsoWeek,
-  type SolvedCompletionSample,
-} from "@/lib/taskmark/timeframe-filters"
-
-export type MetricLeafKind = "epic" | "story" | "task" | "bug"
-
-export type MetricLeaf = {
-  kind: MetricLeafKind
-  id: string
-  status: string
-  points: number
-  completedAt: string
-  reporters: ContributorIdentity[]
-  resolvers: ContributorIdentity[]
-}
-
-export type ProjectStatusMetrics = {
-  totalWorkItems: number
-  completeWorkItems: number
-  /** Story points completed in the current ISO week from done task/bug leaves. */
-  currentWeekPointsDone: number
-  /** Average story points completed per ISO week over the 90-day window; null if no done tasks/bugs. */
-  currentSpeedPtsPerWeek: number | null
-  /** Weeks included in the speed average (0 when no speed). */
-  speedWeekCount: number
-  contributors: ContributorIdentity[]
-}
-
-const COUNTABLE_KINDS = new Set<MetricLeafKind>(["story", "task", "bug"])
-
-function emailKey(email: string, name: string): string {
-  const e = email.trim().toLowerCase()
-  if (e) return `e:${e}`
-  return `n:${name.trim().toLowerCase()}`
-}
-
-/** Merge identities by email (prefer richer name/initials). */
-export function collectUniqueContributors(
-  leaves: readonly MetricLeaf[]
-): ContributorIdentity[] {
-  const map = new Map<string, ContributorIdentity>()
-  for (const leaf of leaves) {
-    for (const person of [...leaf.reporters, ...leaf.resolvers]) {
-      const key = emailKey(person.email, person.name)
-      const cur = map.get(key)
-      if (!cur) {
-        map.set(key, { ...person })
-        continue
-      }
-      if (!cur.name && person.name) cur.name = person.name
-      if (!cur.email && person.email) cur.email = person.email
-      if (!cur.initials && person.initials) cur.initials = person.initials
-    }
-  }
-  return [...map.values()].sort((a, b) => {
-    const an = (a.name || a.email).toLowerCase()
-    const bn = (b.name || b.email).toLowerCase()
-    if (an !== bn) return an < bn ? -1 : 1
-    return (a.email || "").localeCompare(b.email || "")
-  })
-}
-
-/**
- * Total / complete counts for stories + bugs + tasks.
- * Excludes epics and cancelled items.
- */
-export function aggregateWorkItemCounts(leaves: readonly MetricLeaf[]): {
-  total: number
-  complete: number
-} {
-  let total = 0
-  let complete = 0
-  for (const leaf of leaves) {
-    if (!COUNTABLE_KINDS.has(leaf.kind)) continue
-    const status = leaf.status.trim().toLowerCase()
-    if (status === "cancelled") continue
-    total += 1
-    if (status === "done") complete += 1
-  }
-  return { total, complete }
-}
-
-/** ISO weeks from `from` through `to` inclusive (by week of each date). */
-export function isoWeeksInclusive(
-  from: Date,
-  to: Date
-): { year: number; week: number }[] {
-  const start = from.getTime() <= to.getTime() ? from : to
-  const end = from.getTime() <= to.getTime() ? to : from
-  let { year, week } = isoWeekParts(start)
-  const endParts = isoWeekParts(end)
-  const out: { year: number; week: number }[] = []
-  // Safety cap (~3 years of weeks)
-  for (let i = 0; i < 200; i++) {
-    out.push({ year, week })
-    if (year === endParts.year && week === endParts.week) break
-    const next = shiftIsoWeek(year, week, 1)
-    year = next.year
-    week = next.week
-  }
-  return out
-}
-
-function isCompletedTaskBugLeaf(leaf: MetricLeaf): boolean {
-  if (leaf.kind !== "task" && leaf.kind !== "bug") return false
-  if (leaf.status.trim().toLowerCase() !== "done") return false
-  if (!leaf.completedAt.trim()) return false
-  return true
-}
-
-/** The exact completed task/bug leaf set used by Current Speed. */
-export function collectCompletedLeafPointSamples(
-  leaves: readonly MetricLeaf[]
-): SolvedCompletionSample[] {
-  return leaves
-    .filter(isCompletedTaskBugLeaf)
-    .map((leaf) => ({
-      completedAt: leaf.completedAt,
-      points: leaf.points,
-    }))
-}
-
-/**
- * Current Speed: average weekly story points of done tasks/bugs.
- *
- * - Anchor = most recently completed task/bug (`completed_at`); look back 90 days.
- * - Exclude the **current** ISO week (incomplete / in progress).
- * - Exclude weeks with **0** points (idle/hold — not in numerator or denominator).
- * - Average = sum(non-zero past weeks) / count(those weeks).
- */
-export function computeCurrentSpeedPtsPerWeek(
-  leaves: readonly MetricLeaf[],
-  now: Date = new Date()
-): { average: number | null; weekCount: number } {
-  const doneLeaves = leaves.filter(isCompletedTaskBugLeaf)
-
-  let latest: Date | null = null
-  for (const leaf of doneLeaves) {
-    const d = parseTaskmarkDate(leaf.completedAt)
-    if (!d) continue
-    if (!latest || d.getTime() > latest.getTime()) latest = d
-  }
-  if (!latest) return { average: null, weekCount: 0 }
-
-  const windowStart = addDays(latest, -90)
-  const weeks = isoWeeksInclusive(windowStart, latest)
-  if (weeks.length === 0) return { average: null, weekCount: 0 }
-
-  const current = isoWeekParts(now)
-  const currentKey = isoWeekCountKey(current.year, current.week)
-
-  const pointsByWeek = new Map<string, number>()
-  for (const w of weeks) {
-    const key = isoWeekCountKey(w.year, w.week)
-    if (key === currentKey) continue // ignore current week
-    pointsByWeek.set(key, 0)
-  }
-
-  for (const leaf of doneLeaves) {
-    const d = parseTaskmarkDate(leaf.completedAt)
-    if (!d) continue
-    if (d.getTime() < windowStart.getTime() || d.getTime() > latest.getTime()) {
-      continue
-    }
-    const { year, week } = isoWeekParts(d)
-    const key = isoWeekCountKey(year, week)
-    if (!pointsByWeek.has(key)) continue
-    const pts = Number.isFinite(leaf.points) ? Math.max(0, leaf.points) : 0
-    pointsByWeek.set(key, (pointsByWeek.get(key) ?? 0) + pts)
-  }
-
-  // Only weeks with completed points contribute to the average
-  const considered = [...pointsByWeek.values()].filter((pts) => pts > 0)
-  if (considered.length === 0) return { average: null, weekCount: 0 }
-
-  const sum = considered.reduce((a, b) => a + b, 0)
-  return { average: sum / considered.length, weekCount: considered.length }
-}
-
-export function computeCurrentWeekPointsDone(
-  leaves: readonly MetricLeaf[],
-  now: Date = new Date()
-): number {
-  const current = isoWeekParts(now)
-  let total = 0
-  for (const leaf of leaves) {
-    if (!isCompletedTaskBugLeaf(leaf)) continue
-    const date = parseTaskmarkDate(leaf.completedAt)
-    if (!date) continue
-    const parts = isoWeekParts(date)
-    if (parts.year !== current.year || parts.week !== current.week) continue
-    total += Number.isFinite(leaf.points) ? Math.max(0, leaf.points) : 0
-  }
-  return total
-}
-
-/** Walk the board and collect metric leaves (stories, tasks, bugs + epic identities for contributors). */
-export function collectMetricLeaves(
-  project: DiscoveredProject
-): MetricLeaf[] {
-  const epicList = parseEpicsForProject(project)
-  const leaves: MetricLeaf[] = []
-
-  for (const epic of epicList.epics) {
-    leaves.push({
-      kind: "epic",
-      id: epic.id,
-      status: epic.status,
-      points: epic.points ?? 0,
-      completedAt: epic.completedAt,
-      reporters: epic.reporters,
-      resolvers: epic.resolvers,
-    })
-
-    const storyList = parseStoriesForEpic(project, epic.id)
-    for (const story of storyList.stories) {
-      leaves.push({
-        kind: "story",
-        id: story.id,
-        status: story.status,
-        points: story.points ?? 0,
-        completedAt: story.completedAt,
-        reporters: story.reporters,
-        resolvers: story.resolvers,
-      })
-
-      const items = parseItemsForStory(project, epic.id, story.id)
-      for (const item of items.items) {
-        leaves.push({
-          kind: item.type,
-          id: item.id,
-          status: item.status,
-          points: item.points ?? 0,
-          completedAt: item.completedAt,
-          reporters: item.reporters,
-          resolvers: item.resolvers,
-        })
-      }
-    }
-
-    const epicItems = parseItemsForEpic(project, epic.id)
-    for (const item of epicItems.items) {
-      leaves.push({
-        kind: item.type,
-        id: item.id,
-        status: item.status,
-        points: item.points ?? 0,
-        completedAt: item.completedAt,
-        reporters: item.reporters,
-        resolvers: item.resolvers,
-      })
-    }
-  }
-
-  return leaves
-}
-
-export function computeProjectStatusMetrics(
-  project: DiscoveredProject
-): ProjectStatusMetrics {
-  const leaves = collectMetricLeaves(project)
-  const { total, complete } = aggregateWorkItemCounts(leaves)
-  const currentWeekPointsDone = computeCurrentWeekPointsDone(leaves)
-  const speed = computeCurrentSpeedPtsPerWeek(leaves)
-  return {
-    totalWorkItems: total,
-    completeWorkItems: complete,
-    currentWeekPointsDone,
-    currentSpeedPtsPerWeek: speed.average,
-    speedWeekCount: speed.weekCount,
-    contributors: collectUniqueContributors(leaves),
-  }
-}
-
-/** Format average pts/week for display (one decimal when needed). */
-export function formatSpeedPtsPerWeek(value: number | null): string {
-  if (value == null || !Number.isFinite(value)) return "—"
-  const rounded = Math.round(value * 10) / 10
-  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1)
-}

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

@@ -1,55 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-
-/** Dedicated multi-repo board folder names end with `-taskmark`. */
-export function isDedicatedBoardRepoName(name: string): boolean {
-  return name.endsWith("-taskmark")
-}
-
-/** Stable absolute identity for a board (dedupe key + cookie id). */
-export function resolveBoardKey(boardPath: string): string {
-  const resolved = path.resolve(boardPath)
-  try {
-    return fs.realpathSync(resolved)
-  } catch {
-    return resolved
-  }
-}
-
-/**
- * Project root for a board path:
- * - nested `<project>/taskmark` → `<project>`
- * - flat dedicated `<name>-taskmark` → that folder itself
- */
-export function projectPathForBoard(boardPath: string): string {
-  const resolved = path.resolve(boardPath)
-  const base = path.basename(resolved)
-  if (isDedicatedBoardRepoName(base)) return resolved
-  if (base === "taskmark") return path.dirname(resolved)
-  return path.dirname(resolved)
-}
-
-export function projectNameForBoard(boardPath: string): string {
-  return path.basename(projectPathForBoard(boardPath))
-}
-
-/** Collapse duplicate boards that resolve to the same path. */
-export function dedupeProjects(
-  projects: DiscoveredProject[]
-): DiscoveredProject[] {
-  const byKey = new Map<string, DiscoveredProject>()
-  for (const project of projects) {
-    const key = resolveBoardKey(project.boardPath)
-    if (byKey.has(key)) continue
-    byKey.set(key, {
-      ...project,
-      id: key,
-      boardPath: key,
-      projectPath: projectPathForBoard(key),
-      name: projectNameForBoard(key),
-    })
-  }
-  return [...byKey.values()].sort((a, b) => a.name.localeCompare(b.name))
-}

package/dist/standalone/dist/standalone/lib/taskmark/resolve-work-item.ts

@@ -1,219 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-import {
-  asString,
-  extractFrontmatter,
-} from "@/lib/taskmark/frontmatter"
-import type { WorkItemRef } from "@/lib/taskmark/detail-types"
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-
-export type ResolvedWorkItem = WorkItemRef & {
-  boardPath: string
-  projectId: string
-}
-
-function readIdTitleType(
-  filePath: string
-): { id: string; title: string; type: string } | null {
-  try {
-    const raw = fs.readFileSync(filePath, "utf8")
-    const fm = extractFrontmatter(raw)
-    if (!fm) return null
-    const id = asString(fm.id)
-    const title = asString(fm.title)
-    if (!id) return null
-    return { id, title, type: asString(fm.type).toLowerCase() }
-  } catch {
-    return null
-  }
-}
-
-function toRef(
-  meta: { id: string; title: string; type: string },
-  filePath: string
-): WorkItemRef | null {
-  if (meta.type === "epic" || meta.id.startsWith("E-")) {
-    return {
-      kind: "epic",
-      id: meta.id,
-      title: meta.title || meta.id,
-      filePath,
-    }
-  }
-  if (meta.type === "story" || meta.id.startsWith("S-")) {
-    return {
-      kind: "story",
-      id: meta.id,
-      title: meta.title || meta.id,
-      filePath,
-    }
-  }
-  if (
-    meta.type === "task" ||
-    meta.type === "bug" ||
-    meta.id.startsWith("T-") ||
-    meta.id.startsWith("B-")
-  ) {
-    const itemType =
-      meta.type === "bug" || meta.id.startsWith("B-") ? "bug" : "task"
-    return {
-      kind: "item",
-      id: meta.id,
-      title: meta.title || meta.id,
-      filePath,
-      itemType,
-    }
-  }
-  return null
-}
-
-/** Find a work item markdown file by id under one board root. */
-export function findWorkItemOnBoard(
-  boardPath: string,
-  itemId: string
-): WorkItemRef | null {
-  const id = itemId.trim()
-  if (!id) return null
-
-  const epicsDir = path.join(boardPath, "epics")
-  let epicEntries: fs.Dirent[]
-  try {
-    epicEntries = fs.readdirSync(epicsDir, { withFileTypes: true })
-  } catch {
-    return null
-  }
-
-  for (const epicEntry of epicEntries) {
-    if (!epicEntry.isDirectory() || epicEntry.name.startsWith(".")) continue
-    const epicDir = path.join(epicsDir, epicEntry.name)
-
-    const epicFile = path.join(epicDir, "epic.md")
-    if (fs.existsSync(epicFile)) {
-      const meta = readIdTitleType(epicFile)
-      if (meta?.id === id) return toRef(meta, epicFile)
-    }
-
-    const epicItemsDir = path.join(epicDir, "items")
-    try {
-      for (const name of fs.readdirSync(epicItemsDir)) {
-        if (!name.endsWith(".md") || name.startsWith(".")) continue
-        const filePath = path.join(epicItemsDir, name)
-        const meta = readIdTitleType(filePath)
-        if (meta?.id === id) return toRef(meta, filePath)
-      }
-    } catch {
-      /* no epic-direct items */
-    }
-
-    const storiesDir = path.join(epicDir, "stories")
-    let storyEntries: fs.Dirent[]
-    try {
-      storyEntries = fs.readdirSync(storiesDir, { withFileTypes: true })
-    } catch {
-      continue
-    }
-
-    for (const storyEntry of storyEntries) {
-      if (!storyEntry.isDirectory() || storyEntry.name.startsWith(".")) continue
-      const storyDir = path.join(storiesDir, storyEntry.name)
-      const storyFile = path.join(storyDir, "story.md")
-      if (fs.existsSync(storyFile)) {
-        const meta = readIdTitleType(storyFile)
-        if (meta?.id === id) return toRef(meta, storyFile)
-      }
-
-      const storyItemsDir = path.join(storyDir, "items")
-      try {
-        for (const name of fs.readdirSync(storyItemsDir)) {
-          if (!name.endsWith(".md") || name.startsWith(".")) continue
-          const filePath = path.join(storyItemsDir, name)
-          const meta = readIdTitleType(filePath)
-          if (meta?.id === id) return toRef(meta, filePath)
-        }
-      } catch {
-        /* no story items */
-      }
-    }
-  }
-
-  return null
-}
-
-/** Search configured projects for a work item id.
- * Prefer `preferBoardPath` / `preferProjectId` when set; otherwise first match.
- */
-export function findWorkItemInProjects(
-  projects: DiscoveredProject[],
-  itemId: string,
-  options?: {
-    /** Only search this board (cross-project id collisions). */
-    boardPath?: string | null
-    /** Prefer this project id when scanning multiple boards. */
-    preferProjectId?: string | null
-  }
-): ResolvedWorkItem | null {
-  const boardPath = options?.boardPath?.trim() || null
-  if (boardPath) {
-    const project =
-      projects.find(
-        (p) =>
-          path.resolve(p.boardPath) === path.resolve(boardPath) ||
-          p.boardPath === boardPath
-      ) ?? null
-    const ref = findWorkItemOnBoard(
-      project?.boardPath ?? boardPath,
-      itemId
-    )
-    if (!ref) return null
-    return {
-      ...ref,
-      boardPath: project?.boardPath ?? boardPath,
-      projectId: project?.id ?? boardPath,
-    }
-  }
-
-  const preferId = options?.preferProjectId?.trim() || null
-  const ordered = preferId
-    ? [
-        ...projects.filter(
-          (p) => p.id === preferId || p.boardPath === preferId
-        ),
-        ...projects.filter(
-          (p) => p.id !== preferId && p.boardPath !== preferId
-        ),
-      ]
-    : projects
-
-  // When an active/preferred project is set, only resolve on that board so
-  // shared ids cannot jump to another project.
-  if (preferId) {
-    const preferred = ordered[0]
-    if (
-      preferred &&
-      (preferred.id === preferId || preferred.boardPath === preferId)
-    ) {
-      const ref = findWorkItemOnBoard(preferred.boardPath, itemId)
-      if (ref) {
-        return {
-          ...ref,
-          boardPath: preferred.boardPath,
-          projectId: preferred.id,
-        }
-      }
-      return null
-    }
-  }
-
-  for (const project of ordered) {
-    const ref = findWorkItemOnBoard(project.boardPath, itemId)
-    if (ref) {
-      return {
-        ...ref,
-        boardPath: project.boardPath,
-        projectId: project.id,
-      }
-    }
-  }
-  return null
-}

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

@@ -1,46 +0,0 @@
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-import type { ContributorIdentity } from "@/lib/taskmark/identity"
-
-export type StorySummary = {
-  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
-  parent: string
-  epic: string
-  /** Tasks + bugs under this story. */
-  workItemCount: number
-  /** Done tasks/bugs among workItemCount. */
-  doneWorkItemCount: number
-  /** Absolute path to story.md */
-  filePath: string
-  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
-}
-
-export type StoryParseError = {
-  filePath: string
-  projectId: string
-  projectName: string
-  epicId: string
-  message: string
-}
-
-export type EpicStoryList = {
-  project: DiscoveredProject
-  epicId: string
-  epicTitle: string | null
-  stories: StorySummary[]
-  errors: StoryParseError[]
-}