@taskmark/ui 0.1.0

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

@@ -0,0 +1,25 @@
+/** Reserved default epic for general tasks and user stories. */
+export function isGeneralEpic(epic: {
+  id: string
+  title: string
+  tags: string[]
+  filePath: string
+}): boolean {
+  if (epic.title.trim().toLowerCase() === "general") return true
+  if (epic.tags.some((t) => t.trim().toLowerCase() === "general")) return true
+  const folder = epic.filePath.replace(/[/\\]epic\.md$/i, "")
+  const base = folder.split(/[/\\]/).pop() ?? ""
+  return base.toLowerCase().endsWith("-general") || base.toLowerCase() === "general"
+}
+
+/** Sort so General appears first, then by id. */
+export function sortEpicsGeneralFirst<T extends { id: string; title: string; tags: string[]; filePath: string }>(
+  epics: T[]
+): T[] {
+  return [...epics].sort((a, b) => {
+    const ag = isGeneralEpic(a)
+    const bg = isGeneralEpic(b)
+    if (ag !== bg) return ag ? -1 : 1
+    return a.id.localeCompare(b.id)
+  })
+}

package/dist/standalone/dist/standalone/dist/standalone/lib/taskmark/hide-completed-cookie.ts

@@ -0,0 +1,40 @@
+import {
+  HIDE_COMPLETED_COOKIE_MAX_AGE,
+  HIDE_COMPLETED_COOKIES,
+  type HideCompletedCookieKey,
+} from "@/lib/taskmark/constants"
+
+export type { HideCompletedCookieKey }
+
+export function hideCompletedCookieName(
+  key: HideCompletedCookieKey
+): string {
+  return HIDE_COMPLETED_COOKIES[key]
+}
+
+export function parseHideCompletedCookieValue(
+  value: string | null | undefined
+): boolean {
+  return value === "1" || value === "true"
+}
+
+/** Client-only read of a Hide completed cookie. */
+export function readHideCompletedCookieClient(
+  key: HideCompletedCookieKey
+): boolean {
+  if (typeof document === "undefined") return false
+  const name = hideCompletedCookieName(key)
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  const match = document.cookie.match(new RegExp(`(?:^|; )${escaped}=([^;]*)`))
+  return parseHideCompletedCookieValue(match?.[1])
+}
+
+/** Persist Hide completed for one list (client-readable cookie). */
+export function writeHideCompletedCookieClient(
+  key: HideCompletedCookieKey,
+  hide: boolean
+): void {
+  if (typeof document === "undefined") return
+  const name = hideCompletedCookieName(key)
+  document.cookie = `${name}=${hide ? "1" : "0"}; path=/; max-age=${HIDE_COMPLETED_COOKIE_MAX_AGE}; SameSite=Lax`
+}

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

@@ -0,0 +1,182 @@
+/** Contributor identity from git config (name, email, initials). */
+
+export type ContributorIdentity = {
+  name: string
+  email: string
+  initials: string
+}
+
+export function deriveInitials(name: string): string {
+  const parts = name
+    .trim()
+    .split(/[\s\-_.]+/)
+    .filter(Boolean)
+  if (parts.length === 0) return "?"
+  if (parts.length === 1) {
+    const token = parts[0]
+    return (token.length >= 2 ? token.slice(0, 2) : token.slice(0, 1)).toUpperCase()
+  }
+  return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase()
+}
+
+function asIdentity(value: unknown): ContributorIdentity | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null
+  const obj = value as Record<string, unknown>
+  const name =
+    typeof obj.name === "string"
+      ? obj.name
+      : typeof obj.name === "number"
+        ? String(obj.name)
+        : ""
+  const email =
+    typeof obj.email === "string"
+      ? obj.email
+      : typeof obj.email === "number"
+        ? String(obj.email)
+        : ""
+  let initials =
+    typeof obj.initials === "string"
+      ? obj.initials
+      : typeof obj.initials === "number"
+        ? String(obj.initials)
+        : ""
+  if (!name && !email) return null
+  const resolvedName = name || email.split("@")[0] || ""
+  if (!initials) initials = deriveInitials(resolvedName)
+  return { name: resolvedName, email, initials: initials.toUpperCase() }
+}
+
+/** Parse reporters/resolvers YAML lists from frontmatter. */
+export function asContributorList(value: unknown): ContributorIdentity[] {
+  if (!Array.isArray(value)) return []
+  const out: ContributorIdentity[] = []
+  for (const item of value) {
+    const ident = asIdentity(item)
+    if (ident) out.push(ident)
+  }
+  return out
+}
+
+export type AttributionRole = "created" | "resolved" | "both"
+
+export type AttributionAvatar = {
+  identity: ContributorIdentity
+  role: AttributionRole
+  label: string
+}
+
+function emailKey(email: string, name: string): string {
+  const e = email.trim().toLowerCase()
+  if (e) return `e:${e}`
+  return `n:${name.trim().toLowerCase()}`
+}
+
+/** Merge reporters + resolvers into avatar entries with hover labels. */
+export function buildAttributionAvatars(
+  reporters: ContributorIdentity[],
+  resolvers: ContributorIdentity[]
+): AttributionAvatar[] {
+  type Acc = {
+    identity: ContributorIdentity
+    created: boolean
+    resolved: boolean
+  }
+  const map = new Map<string, Acc>()
+
+  for (const r of reporters) {
+    const key = emailKey(r.email, r.name)
+    const cur = map.get(key)
+    if (cur) {
+      cur.created = true
+      if (!cur.identity.name && r.name) cur.identity.name = r.name
+      if (!cur.identity.email && r.email) cur.identity.email = r.email
+      if (!cur.identity.initials) cur.identity.initials = r.initials
+    } else {
+      map.set(key, {
+        identity: { ...r },
+        created: true,
+        resolved: false,
+      })
+    }
+  }
+  for (const r of resolvers) {
+    const key = emailKey(r.email, r.name)
+    const cur = map.get(key)
+    if (cur) {
+      cur.resolved = true
+      if (!cur.identity.name && r.name) cur.identity.name = r.name
+      if (!cur.identity.email && r.email) cur.identity.email = r.email
+      if (!cur.identity.initials) cur.identity.initials = r.initials
+    } else {
+      map.set(key, {
+        identity: { ...r },
+        created: false,
+        resolved: true,
+      })
+    }
+  }
+
+  const out: AttributionAvatar[] = []
+  for (const acc of map.values()) {
+    let role: AttributionRole
+    let label: string
+    const name = acc.identity.name || "Unknown"
+    if (acc.created && acc.resolved) {
+      role = "both"
+      label = `Created and developed by ${name}`
+    } else if (acc.created) {
+      role = "created"
+      label = `Created by ${name}`
+    } else {
+      role = "resolved"
+      label = `Resolved by ${name}`
+    }
+    out.push({ identity: acc.identity, role, label })
+  }
+  return out
+}
+
+/** Curated palette — distinct, readable with white initials. */
+const AVATAR_PALETTE = [
+  "#0f766e", // teal
+  "#1d4ed8", // blue
+  "#7c3aed", // violet
+  "#be185d", // pink
+  "#b45309", // amber
+  "#047857", // green
+  "#c2410c", // orange
+  "#4338ca", // indigo
+  "#0e7490", // cyan
+  "#a16207", // yellow-brown
+  "#9f1239", // rose
+  "#166534", // forest
+  "#6d28d9", // purple
+  "#0369a1", // sky
+  "#9a3412", // rust
+  "#115e59", // teal-dark
+] as const
+
+function hashSeed(seed: string): number {
+  let hash = 0
+  for (let i = 0; i < seed.length; i++) {
+    hash = (hash * 31 + seed.charCodeAt(i)) >>> 0
+  }
+  return hash
+}
+
+/** Stable hue from email/name (legacy). Prefer identityBackgroundColor. */
+export function identityHue(identity: ContributorIdentity): number {
+  const seed = (identity.email || identity.name || "?").toLowerCase()
+  return hashSeed(seed) % 360
+}
+
+/**
+ * Background color from user initials (falls back to email/name).
+ * Same initials → same color; different initials → different palette slots.
+ */
+export function identityBackgroundColor(identity: ContributorIdentity): string {
+  const initials = (identity.initials || "").trim().toUpperCase()
+  const seed = initials || (identity.email || identity.name || "?").toLowerCase()
+  const index = hashSeed(seed) % AVATAR_PALETTE.length
+  return AVATAR_PALETTE[index]
+}

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

@@ -0,0 +1,46 @@
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+import type { ContributorIdentity } from "@/lib/taskmark/identity"
+
+export type ItemType = "task" | "bug"
+
+export type ItemSummary = {
+  id: string
+  type: ItemType
+  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
+  /** Absolute path to the item markdown file */
+  filePath: string
+  project: Pick<DiscoveredProject, "id" | "name" | "projectPath" | "boardPath">
+}
+
+export type ItemParseError = {
+  filePath: string
+  projectId: string
+  projectName: string
+  storyId: string
+  message: string
+}
+
+export type StoryItemList = {
+  project: DiscoveredProject
+  epicId: string
+  storyId: string
+  storyTitle: string | null
+  items: ItemSummary[]
+  errors: ItemParseError[]
+}

package/dist/standalone/dist/standalone/dist/standalone/lib/taskmark/list-filters.ts

@@ -0,0 +1,327 @@
+/** Pure helpers for board list search and filters (client-side). */
+
+import {
+  DEFAULT_TIMEFRAME_FILTER,
+  passesTimeframeFilter,
+  timeframeResetKey,
+  type TimeframeFilterState,
+} from "@/lib/taskmark/timeframe-filters"
+
+export type WorkItemSearchFields = {
+  id: string
+  title: string
+}
+
+export type ListSearchQuery = string
+
+export type ParentFilterKind = "epic" | "story"
+
+export type ParentFilterValue = {
+  kind: ParentFilterKind
+  id: string
+  title: string
+}
+
+/** Stable key for parent filter selection (e.g. `epic:E-010`). */
+export function parentFilterKey(parent: ParentFilterValue): string {
+  return `${parent.kind}:${parent.id}`
+}
+
+export function parseParentFilterKey(
+  key: string | null | undefined
+): { kind: ParentFilterKind; id: string } | null {
+  if (!key) return null
+  const colon = key.indexOf(":")
+  if (colon <= 0) return null
+  const kind = key.slice(0, colon)
+  const id = key.slice(colon + 1)
+  if ((kind !== "epic" && kind !== "story") || !id) return null
+  return { kind, id }
+}
+
+export type ListFilterState = {
+  query: ListSearchQuery
+  hideCompleted: boolean
+  /** Selected parent keys (`epic:…` / `story:…`); empty = no parent filter. */
+  parentKeys: string[]
+  /** Empty = no tag filter; otherwise match any selected tag. */
+  selectedTags: string[]
+  timeframe: TimeframeFilterState
+}
+
+export const DEFAULT_LIST_FILTER_STATE: ListFilterState = {
+  query: "",
+  hideCompleted: false,
+  parentKeys: [],
+  selectedTags: [],
+  timeframe: DEFAULT_TIMEFRAME_FILTER,
+}
+
+export type { TimeframeFilterState }
+export {
+  DEFAULT_TIMEFRAME_FILTER,
+  isTimeframeActive,
+  isWeekRangeSelection,
+  recentWeekRange,
+  timeframeResetKey,
+} from "@/lib/taskmark/timeframe-filters"
+
+export function normalizeSearchQuery(query: string): string {
+  return query.trim().toLowerCase()
+}
+
+/**
+ * Empty / whitespace query matches everything.
+ * Otherwise case-insensitive substring match on id or title.
+ */
+export function matchesWorkItemSearch(
+  query: string,
+  fields: WorkItemSearchFields
+): boolean {
+  const q = normalizeSearchQuery(query)
+  if (!q) return true
+  return (
+    fields.id.toLowerCase().includes(q) ||
+    fields.title.toLowerCase().includes(q)
+  )
+}
+
+export function isCompletedStatus(status: string): boolean {
+  return status.trim().toLowerCase() === "done"
+}
+
+/** True when every child is done (and there is at least one child). */
+export function isChildProgressComplete(
+  done?: number,
+  total?: number
+): boolean {
+  if (total == null || done == null) return false
+  return total > 0 && done >= total
+}
+
+/**
+ * When hideCompleted is on, drop completed rows.
+ *
+ * Prefer child progress when totals are present: a parent with open children
+ * stays visible even if frontmatter status is still `done` (e.g. epic-direct
+ * backlog under a previously completed epic). Otherwise fall back to status.
+ */
+export function passesHideCompleted(
+  hideCompleted: boolean,
+  status: string,
+  progress?: { done?: number; total?: number }
+): boolean {
+  if (!hideCompleted) return true
+  const total = progress?.total
+  const done = progress?.done
+  if (total != null && total > 0 && done != null) {
+    return !isChildProgressComplete(done, total)
+  }
+  return !isCompletedStatus(status)
+}
+
+/** Keep row if it includes any of the selected tags. Empty selection = pass. */
+export function matchesAnySelectedTag(
+  selectedTags: readonly string[],
+  rowTags: readonly string[] | undefined
+): boolean {
+  if (selectedTags.length === 0) return true
+  if (!rowTags || rowTags.length === 0) return false
+  const set = new Set(rowTags.map((t) => t.toLowerCase()))
+  return selectedTags.some((t) => set.has(t.toLowerCase()))
+}
+
+export type ParentFilterableRow = {
+  id: string
+  kind?: string
+  epicId: string
+}
+
+/**
+ * Empty selection → pass.
+ * Otherwise match **any** selected parent:
+ * - epic → rows under that epic
+ * - story → that story row (Work items has no story-child tasks)
+ */
+export function matchesAnyParentFilter(
+  parentKeys: readonly string[],
+  row: ParentFilterableRow
+): boolean {
+  if (parentKeys.length === 0) return true
+  return parentKeys.some((key) => {
+    const parsed = parseParentFilterKey(key)
+    if (!parsed) return false
+    if (parsed.kind === "epic") return row.epicId === parsed.id
+    return row.kind === "story" && row.id === parsed.id
+  })
+}
+
+/** @deprecated Use matchesAnyParentFilter with a single-key array. */
+export function matchesParentFilter(
+  parentKey: string | null,
+  row: ParentFilterableRow
+): boolean {
+  if (!parentKey) return true
+  return matchesAnyParentFilter([parentKey], row)
+}
+
+export function collectUniqueTags(
+  rows: readonly { tags?: readonly string[] }[]
+): string[] {
+  const set = new Set<string>()
+  for (const row of rows) {
+    for (const tag of row.tags ?? []) {
+      const t = tag.trim()
+      if (t) set.add(t)
+    }
+  }
+  return [...set].sort((a, b) => a.localeCompare(b))
+}
+
+export type ParentFilterOption = ParentFilterValue & {
+  key: string
+  /** Full label for the dropdown. */
+  label: string
+  /** Short label for chips (id). */
+  chipLabel: string
+}
+
+/** Build epic + story options from Work items rows. */
+export function buildParentFilterOptions(
+  rows: readonly {
+    id: string
+    title: string
+    kind: string
+    epicId: string
+    epicTitle: string
+  }[]
+): ParentFilterOption[] {
+  const epics = new Map<string, ParentFilterOption>()
+  const stories = new Map<string, ParentFilterOption>()
+
+  for (const row of rows) {
+    if (row.epicId && !epics.has(row.epicId)) {
+      const value: ParentFilterValue = {
+        kind: "epic",
+        id: row.epicId,
+        title: row.epicTitle,
+      }
+      epics.set(row.epicId, {
+        ...value,
+        key: parentFilterKey(value),
+        label: `Epic ${row.epicId}: ${row.epicTitle}`,
+        chipLabel: row.epicId,
+      })
+    }
+    if (row.kind === "story" && !stories.has(row.id)) {
+      const value: ParentFilterValue = {
+        kind: "story",
+        id: row.id,
+        title: row.title,
+      }
+      stories.set(row.id, {
+        ...value,
+        key: parentFilterKey(value),
+        label: `Story ${row.id}: ${row.title}`,
+        chipLabel: row.id,
+      })
+    }
+  }
+
+  return [
+    ...[...epics.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    ...[...stories.values()].sort((a, b) => a.id.localeCompare(b.id)),
+  ]
+}
+
+export type FilterableListRow = WorkItemSearchFields & {
+  status: string
+  tags?: readonly string[]
+  kind?: string
+  epicId?: string
+  /** Solved date (`completed_at`); required for timeframe filtering. */
+  completedAt?: string
+  /** When set with doneWorkItemCount, used for hide-completed on progress rows. */
+  workItemCount?: number
+  doneWorkItemCount?: number
+}
+
+export function filterListRows<T extends FilterableListRow>(
+  rows: readonly T[],
+  state: Pick<
+    ListFilterState,
+    "query" | "hideCompleted" | "selectedTags"
+  > & {
+    parentKeys?: readonly string[]
+    /** @deprecated Prefer parentKeys. */
+    parentKey?: string | null
+    timeframe?: TimeframeFilterState
+  }
+): T[] {
+  const parentKeys =
+    state.parentKeys ??
+    (state.parentKey ? [state.parentKey] : [])
+  const timeframe = state.timeframe ?? DEFAULT_TIMEFRAME_FILTER
+  return rows.filter((row) => {
+    if (!matchesWorkItemSearch(state.query, row)) return false
+    if (
+      !passesHideCompleted(state.hideCompleted, row.status, {
+        done: row.doneWorkItemCount,
+        total: row.workItemCount,
+      })
+    ) {
+      return false
+    }
+    if (!matchesAnySelectedTag(state.selectedTags, row.tags)) return false
+    if (parentKeys.length > 0) {
+      if (!row.epicId) return false
+      if (
+        !matchesAnyParentFilter(parentKeys, {
+          id: row.id,
+          kind: row.kind,
+          epicId: row.epicId,
+        })
+      ) {
+        return false
+      }
+    }
+    if (!passesTimeframeFilter(timeframe, row.completedAt)) return false
+    return true
+  })
+}
+
+/** Compact reset key fragment for pagination when filters change. */
+export function listFilterResetKey(
+  base: string,
+  state: Pick<
+    ListFilterState,
+    "query" | "hideCompleted" | "selectedTags"
+  > & {
+    parentKeys?: readonly string[]
+    /** @deprecated Prefer parentKeys. */
+    parentKey?: string | null
+    timeframe?: TimeframeFilterState
+  }
+): string {
+  const parentKeys =
+    state.parentKeys ??
+    (state.parentKey ? [state.parentKey] : [])
+  const tags = [...state.selectedTags].sort().join(",")
+  const parents = [...parentKeys].sort().join(",")
+  const timeframe = state.timeframe ?? DEFAULT_TIMEFRAME_FILTER
+  return [
+    base,
+    normalizeSearchQuery(state.query),
+    state.hideCompleted ? "1" : "0",
+    parents,
+    tags,
+    timeframeResetKey(timeframe),
+  ].join("|")
+}
+
+/**
+ * Shared shell classes matching ComboboxChips so search and multiselect
+ * filters look the same.
+ */
+export const FILTER_CHIPS_FIELD_CLASS =
+  "flex min-h-8 flex-wrap items-center gap-1 rounded border-2 bg-input bg-clip-padding px-2.5 py-1 text-sm shadow-sm transition-colors focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-primary"