@taskmark/ui 0.2.1 → 0.2.4

package/dist/standalone/bin/lib/resolve-board.mjs

@@ -1,108 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-
-function hasBoardMarkers(boardPath) {
-  return (
-    fs.existsSync(path.join(boardPath, "INDEX.md")) ||
-    fs.existsSync(path.join(boardPath, "epics"))
-  )
-}
-
-function isDedicatedBoardRepoName(name) {
-  return name.endsWith("-taskmark")
-}
-
-/**
- * Resolve a Taskmark board directory from a path (product root, board root, or nested taskmark/).
- * @returns {string | null} absolute board path
- */
-export function resolveBoardAtPath(candidatePath) {
-  const resolved = path.resolve(candidatePath)
-  let stat
-  try {
-    stat = fs.statSync(resolved)
-  } catch {
-    return null
-  }
-  if (!stat.isDirectory()) return null
-
-  const base = path.basename(resolved)
-
-  if (isDedicatedBoardRepoName(base) && hasBoardMarkers(resolved)) {
-    return resolved
-  }
-
-  const nested = path.join(resolved, "taskmark")
-  try {
-    if (fs.statSync(nested).isDirectory() && hasBoardMarkers(nested)) {
-      return nested
-    }
-  } catch {
-    /* ignore */
-  }
-
-  if (hasBoardMarkers(resolved)) {
-    return resolved
-  }
-
-  return null
-}
-
-function cwdCandidates() {
-  const out = []
-  const seen = new Set()
-  for (const raw of [
-    process.env.TASKMARK_CWD,
-    process.env.INIT_CWD,
-    process.cwd(),
-  ]) {
-    if (!raw || !String(raw).trim()) continue
-    const resolved = path.resolve(String(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
-}
-
-/**
- * Same precedence as the Next app autoconfig:
- * TASKMARK_BOARD → TASKMARK_MASTER (as board-or-master) → cwd.
- * @returns {{ boardPath: string, source: string } | null}
- */
-export function resolveServeBoard(explicitBoard) {
-  if (explicitBoard) {
-    const board = resolveBoardAtPath(explicitBoard)
-    if (board) return { boardPath: board, source: "flag" }
-    return null
-  }
-
-  const boardEnv = process.env.TASKMARK_BOARD?.trim()
-  if (boardEnv) {
-    const board = resolveBoardAtPath(boardEnv)
-    if (board) return { boardPath: board, source: "env_board" }
-  }
-
-  const masterEnv = process.env.TASKMARK_MASTER?.trim()
-  if (masterEnv) {
-    const board = resolveBoardAtPath(masterEnv)
-    if (board) return { boardPath: board, source: "env_master" }
-    // Master may contain a nested board one level down — check common layouts only.
-    const nested = resolveBoardAtPath(path.join(masterEnv, "taskmark"))
-    if (nested) return { boardPath: nested, source: "env_master" }
-  }
-
-  for (const candidate of cwdCandidates()) {
-    const board = resolveBoardAtPath(candidate)
-    if (board) return { boardPath: board, source: "cwd" }
-  }
-
-  return null
-}

package/dist/standalone/bin/taskmark.js

@@ -1,278 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process"
-import fs from "node:fs"
-import http from "node:http"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-import { resolveServeBoard } from "./lib/resolve-board.mjs"
-
-const DEFAULT_PORT = 8275
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const packageRoot = path.resolve(__dirname, "..")
-
-function printHelp() {
-  console.log(`Usage:
-  taskmark serve [options]
-  taskmark build [options]
-
-Commands:
-  serve              Start the prebuilt local UI server (default port ${DEFAULT_PORT})
-  build              Production static HTML export for Vercel / static hosting
-
-Options:
-  --port, -p <n>     Listen port for serve (default ${DEFAULT_PORT}; env PORT / TASKMARK_PORT)
-  --board <path>     Board or product root (sets TASKMARK_BOARD)
-  --out <dir>        Static output directory for build (default: <board>/out)
-  --no-open          Do not open a browser (serve)
-  --help, -h         Show help
-
-Board resolution (same as the UI):
-  1. --board / TASKMARK_BOARD
-  2. TASKMARK_MASTER
-  3. TASKMARK_CWD → npm INIT_CWD → process.cwd()
-     (product root with ./taskmark/, or dedicated *-taskmark root)
-
-Examples:
-  npm i @taskmark/ui --save && npx taskmark serve
-  npx taskmark build --board .
-  npx -p @taskmark/ui taskmark serve
-  npx taskmark serve --port 9000
-  TASKMARK_BOARD=/path/to/my-app/taskmark npx taskmark serve
-`)
-}
-
-function parseArgs(argv) {
-  const args = {
-    command: null,
-    port: null,
-    board: null,
-    out: null,
-    open: true,
-    help: false,
-  }
-  const rest = [...argv]
-  if (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h") {
-    args.help = true
-    return args
-  }
-  args.command = rest.shift()
-  while (rest.length) {
-    const token = rest.shift()
-    if (token === "--help" || token === "-h") {
-      args.help = true
-    } else if (token === "--no-open") {
-      args.open = false
-    } else if (token === "--port" || token === "-p") {
-      args.port = rest.shift()
-    } else if (token === "--board") {
-      args.board = rest.shift()
-    } else if (token === "--out") {
-      args.out = rest.shift()
-    } else if (token.startsWith("--port=")) {
-      args.port = token.slice("--port=".length)
-    } else if (token.startsWith("--board=")) {
-      args.board = token.slice("--board=".length)
-    } else if (token.startsWith("--out=")) {
-      args.out = token.slice("--out=".length)
-    } else {
-      console.error(`Unknown argument: ${token}`)
-      args.help = true
-    }
-  }
-  return args
-}
-
-function resolvePort(raw) {
-  const fromEnv = process.env.TASKMARK_PORT || process.env.PORT
-  const value = raw ?? fromEnv ?? String(DEFAULT_PORT)
-  const n = Number.parseInt(String(value), 10)
-  if (!Number.isFinite(n) || n < 1 || n > 65535) {
-    throw new Error(`Invalid port: ${value}`)
-  }
-  return n
-}
-
-function findStandaloneServer() {
-  const candidates = [
-    path.join(packageRoot, "dist", "standalone", "server.js"),
-    path.join(packageRoot, ".next", "standalone", "server.js"),
-  ]
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate
-  }
-  return null
-}
-
-function openBrowser(url) {
-  const platform = process.platform
-  let cmd
-  let cmdArgs
-  if (platform === "darwin") {
-    cmd = "open"
-    cmdArgs = [url]
-  } else if (platform === "win32") {
-    cmd = "cmd"
-    cmdArgs = ["/c", "start", "", url]
-  } else {
-    cmd = "xdg-open"
-    cmdArgs = [url]
-  }
-  const child = spawn(cmd, cmdArgs, {
-    stdio: "ignore",
-    detached: true,
-  })
-  child.on("error", () => {
-    console.log(`Open this URL in your browser: ${url}`)
-  })
-  child.unref()
-}
-
-function waitForServer(port, timeoutMs = 60_000) {
-  const started = Date.now()
-  return new Promise((resolve, reject) => {
-    const tryOnce = () => {
-      const req = http.get(
-        { host: "127.0.0.1", port, path: "/", timeout: 2000 },
-        (res) => {
-          res.resume()
-          resolve()
-        }
-      )
-      req.on("error", () => {
-        if (Date.now() - started > timeoutMs) {
-          reject(new Error(`Server did not become ready on port ${port}`))
-          return
-        }
-        setTimeout(tryOnce, 250)
-      })
-    }
-    tryOnce()
-  })
-}
-
-async function serve(args) {
-  const resolved = resolveServeBoard(args.board)
-  if (!resolved) {
-    console.error(`No Taskmark board found.
-
-Looked for:
-  - --board / TASKMARK_BOARD
-  - TASKMARK_MASTER
-  - cwd layouts: nested ./taskmark/ or dedicated *-taskmark root
-
-Fix: cd into a product repo (with ./taskmark/) or a board root, or set TASKMARK_BOARD.
-Then re-run: npx taskmark serve
-(or: npx -p @taskmark/ui taskmark serve)`)
-    process.exit(1)
-  }
-
-  const serverJs = findStandaloneServer()
-  if (!serverJs) {
-    console.error(`Prebuilt server not found.
-
-From the taskmark package source, run:
-  npm run build
-
-Or install a published build that includes dist/standalone.`)
-    process.exit(1)
-  }
-
-  const port = resolvePort(args.port)
-  const url = `http://localhost:${port}`
-  const standaloneDir = path.dirname(serverJs)
-
-  console.log(`Taskmark UI`)
-  console.log(`  board:  ${resolved.boardPath} (${resolved.source})`)
-  console.log(`  listen: ${url}`)
-
-  const child = spawn(process.execPath, [serverJs], {
-    cwd: standaloneDir,
-    env: {
-      ...process.env,
-      PORT: String(port),
-      HOSTNAME: "0.0.0.0",
-      TASKMARK_BOARD: resolved.boardPath,
-    },
-    stdio: "inherit",
-  })
-
-  const shutdown = (signal) => {
-    if (!child.killed) child.kill(signal)
-  }
-  process.on("SIGINT", () => shutdown("SIGINT"))
-  process.on("SIGTERM", () => shutdown("SIGTERM"))
-
-  child.on("exit", (code, signal) => {
-    if (signal) process.exit(1)
-    process.exit(code ?? 0)
-  })
-
-  const hosted =
-    Boolean(process.env.VERCEL) ||
-    Boolean(process.env.NOW_REGION) ||
-    process.env.CI === "true"
-  const shouldOpen = args.open && !hosted
-
-  try {
-    await waitForServer(port)
-    if (shouldOpen) {
-      openBrowser(url)
-    } else {
-      console.log(`Ready: ${url}`)
-    }
-  } catch (err) {
-    console.error(String(err?.message || err))
-    shutdown("SIGTERM")
-    process.exit(1)
-  }
-}
-
-async function main() {
-  const args = parseArgs(process.argv.slice(2))
-  if (args.help || !args.command) {
-    printHelp()
-    process.exit(args.help || !args.command ? 0 : 1)
-  }
-  if (args.command === "serve") {
-    try {
-      await serve(args)
-    } catch (err) {
-      console.error(String(err?.message || err))
-      process.exit(1)
-    }
-    return
-  }
-  if (args.command === "build") {
-    const buildScript = path.join(packageRoot, "scripts", "build-static.mjs")
-    // Resolve relative paths against the caller's cwd (npm/yarn script dir),
-    // not packageRoot — the child runs with cwd = @taskmark/ui.
-    const callerCwd = process.env.INIT_CWD || process.cwd()
-    const childArgs = [buildScript]
-    if (args.board) {
-      childArgs.push("--board", path.resolve(callerCwd, args.board))
-    } else {
-      // Prefer the invoke directory as the board when no --board flag.
-      childArgs.push("--board", callerCwd)
-    }
-    if (args.out) {
-      childArgs.push("--out", path.resolve(callerCwd, args.out))
-    }
-    const child = spawn(process.execPath, childArgs, {
-      cwd: packageRoot,
-      env: {
-        ...process.env,
-        INIT_CWD: callerCwd,
-        TASKMARK_CWD: process.env.TASKMARK_CWD || callerCwd,
-      },
-      stdio: "inherit",
-    })
-    child.on("exit", (code) => process.exit(code ?? 1))
-    return
-  }
-  console.error(`Unknown command: ${args.command}`)
-  printHelp()
-  process.exit(1)
-}
-
-main()

package/dist/standalone/components/board/app-bar.tsx

@@ -1,99 +0,0 @@
-"use client"
-
-import { selectActiveProject, openAddProject } from "@/app/setup/actions"
-import { BrandLogo } from "@/components/brand-logo"
-import { Button } from "@/components/ui/button"
-import { projectOptionLabel } from "@/lib/taskmark/project-label"
-import type { DiscoveredProject } from "@/lib/taskmark/types"
-
-type AppBarProps = {
-  projects: DiscoveredProject[]
-  activeProjectId: string
-  masterCount: number
-  /** When true, workspace is env/cwd-bound — hide multi-master add. */
-  autoconfig?: boolean
-}
-
-export function AppBar({
-  projects,
-  activeProjectId,
-  masterCount,
-  autoconfig = false,
-}: AppBarProps) {
-  return (
-    <header className="sticky top-0 z-40 border-b-2 border-border bg-card/95 shadow-sm backdrop-blur">
-      <div className="mx-auto flex w-full max-w-5xl flex-wrap items-center gap-3 px-4 pt-3.5 pb-4">
-        <div className="group flex min-w-0 flex-1 items-center gap-3 transition-[gap] duration-200 group-hover:gap-4">
-          <BrandLogo
-            alt=""
-            width={40}
-            height={45}
-            className="mb-0.5 h-10 w-auto shrink-0 origin-center select-none object-contain transition-transform duration-200 group-hover:scale-110"
-          />
-          <div className="flex min-w-0 flex-col gap-0.5">
-            <p className="w-fit cursor-default font-head text-2xl leading-none tracking-tight">
-              <span className="relative inline-block transition-transform duration-200 group-hover:-rotate-2">
-                Taskmark
-                <svg
-                  aria-hidden
-                  viewBox="0 0 120 10"
-                  preserveAspectRatio="none"
-                  className="pointer-events-none absolute -bottom-1.5 -left-1 h-2.5 w-[calc(100%+1rem)] origin-left text-primary opacity-0 transition-opacity duration-200 group-hover:opacity-100"
-                >
-                  {/* Linear hand stroke: thin at start, thicker at end */}
-                  <path
-                    fill="currentColor"
-                    d="M1 5.2 L119 3.2 L119 8.8 L1 5.9 Z"
-                  />
-                </svg>
-              </span>
-            </p>
-            <p className="truncate text-xs text-muted-foreground transition-transform duration-200 group-hover:translate-y-1">
-              {projects.length} project{projects.length === 1 ? "" : "s"}
-              {masterCount > 0
-                ? ` · ${masterCount} workspace${masterCount === 1 ? "" : "s"}`
-                : ""}
-            </p>
-          </div>
-        </div>
-
-        <form
-          action={selectActiveProject}
-          className="flex min-w-0 flex-wrap items-center gap-2"
-        >
-          <label htmlFor="projectId" className="sr-only">
-            Active project
-          </label>
-          <select
-            id="projectId"
-            name="projectId"
-            defaultValue={activeProjectId}
-            onChange={(e) => {
-              e.currentTarget.form?.requestSubmit()
-            }}
-            className="max-w-[20rem] rounded border-2 border-border bg-input px-3 py-1.5 text-sm shadow-sm outline-none focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring"
-          >
-            {projects.map((project) => (
-              <option key={project.id} value={project.id}>
-                {projectOptionLabel(project, projects)}
-              </option>
-            ))}
-          </select>
-          <noscript>
-            <Button type="submit" size="sm" variant="outline">
-              Switch project
-            </Button>
-          </noscript>
-        </form>
-
-        {!autoconfig ? (
-          <form action={openAddProject}>
-            <Button type="submit" variant="outline" size="sm">
-              Add project
-            </Button>
-          </form>
-        ) : null}
-      </div>
-    </header>
-  )
-}

package/dist/standalone/components/board/attribution-avatars.tsx

@@ -1,176 +0,0 @@
-"use client"
-
-import type { ReactNode } from "react"
-import {
-  Avatar,
-  AvatarFallback,
-  AvatarGroup,
-} from "@/components/ui/avatar"
-import {
-  Tooltip,
-  TooltipContent,
-  TooltipProvider,
-  TooltipTrigger,
-} from "@/components/ui/tooltip"
-import { cn } from "@/lib/utils"
-import type {
-  AttributionAvatar,
-  AttributionRole,
-  ContributorIdentity,
-} from "@/lib/taskmark/identity"
-import {
-  buildAttributionAvatars,
-  identityBackgroundColor,
-} from "@/lib/taskmark/identity"
-
-function ContributorAvatar({
-  identity,
-  label,
-  className,
-  size = "sm",
-}: {
-  identity: ContributorIdentity
-  label: string
-  className?: string
-  size?: "default" | "sm" | "lg"
-}) {
-  const backgroundColor = identityBackgroundColor(identity)
-  return (
-    <Tooltip>
-      <TooltipTrigger
-        render={<span className="inline-flex cursor-default" />}
-        aria-label={label}
-      >
-        <Avatar size={size} className={className}>
-          <AvatarFallback
-            className={cn(
-              "bg-transparent font-semibold tracking-wide text-white !text-[7px]"
-            )}
-            style={{ backgroundColor }}
-          >
-            {identity.initials || "?"}
-          </AvatarFallback>
-        </Avatar>
-      </TooltipTrigger>
-      <TooltipContent side="top">{label}</TooltipContent>
-    </Tooltip>
-  )
-}
-
-export function AttributionAvatarGroup({
-  reporters,
-  resolvers,
-  className,
-  empty = null,
-}: {
-  reporters: ContributorIdentity[]
-  resolvers: ContributorIdentity[]
-  className?: string
-  empty?: ReactNode
-}) {
-  const avatars = buildAttributionAvatars(reporters, resolvers)
-  if (avatars.length === 0) return <>{empty}</>
-
-  return (
-    <TooltipProvider delay={200}>
-      <AvatarGroup
-        className={cn("justify-start", className)}
-        role="group"
-        aria-label="Work item contributors"
-      >
-        {avatars.map((av: AttributionAvatar) => (
-          <ContributorAvatar
-            key={`${av.identity.email}|${av.identity.name}|${av.role}`}
-            identity={av.identity}
-            label={av.label}
-          />
-        ))}
-      </AvatarGroup>
-    </TooltipProvider>
-  )
-}
-
-/** Detail-sheet people: role heading above each person (avatar, name, email). */
-export function AttributionPeopleList({
-  reporters,
-  resolvers,
-  className,
-  empty = "—",
-}: {
-  reporters: ContributorIdentity[]
-  resolvers: ContributorIdentity[]
-  className?: string
-  empty?: ReactNode
-}) {
-  const people = buildAttributionAvatars(reporters, resolvers)
-  if (people.length === 0) return <>{empty}</>
-
-  const sections = (
-    [
-      {
-        role: "both" as const,
-        heading: "Created and developed by",
-        people: people.filter((p) => p.role === "both"),
-      },
-      {
-        role: "created" as const,
-        heading: "Created by",
-        people: people.filter((p) => p.role === "created"),
-      },
-      {
-        role: "resolved" as const,
-        heading: "Resolved by",
-        people: people.filter((p) => p.role === "resolved"),
-      },
-    ] satisfies {
-      role: AttributionRole
-      heading: string
-      people: AttributionAvatar[]
-    }[]
-  ).filter((s) => s.people.length > 0)
-
-  return (
-    <TooltipProvider delay={200}>
-      <div
-        className={cn("flex flex-col gap-3", className)}
-        aria-label="Work item contributors"
-      >
-        {sections.map((section) => (
-          <div key={section.role} className="flex flex-col gap-1.5">
-            <p className="text-xs font-medium text-muted-foreground">
-              {section.heading}
-            </p>
-            <ul className="flex flex-col gap-2">
-              {section.people.map((person) => {
-                const name = person.identity.name || "Unknown"
-                const email = person.identity.email
-                return (
-                  <li
-                    key={`${person.identity.email}|${person.identity.name}|${person.role}`}
-                    className="flex min-w-0 items-center gap-2.5"
-                  >
-                    <ContributorAvatar
-                      identity={person.identity}
-                      label={person.label}
-                      size="default"
-                    />
-                    <div className="min-w-0 flex-1">
-                      <p className="truncate text-sm font-medium leading-tight">
-                        {name}
-                      </p>
-                      {email ? (
-                        <p className="truncate font-mono text-xs font-normal text-muted-foreground">
-                          {email}
-                        </p>
-                      ) : null}
-                    </div>
-                  </li>
-                )
-              })}
-            </ul>
-          </div>
-        ))}
-      </div>
-    </TooltipProvider>
-  )
-}

package/dist/standalone/components/board/child-progress-bar.tsx

@@ -1,40 +0,0 @@
-"use client"
-
-import {
-  Progress,
-  ProgressLabel,
-  ProgressValue,
-} from "@/components/ui/progress"
-import { cn } from "@/lib/utils"
-
-type ChildProgressBarProps = {
-  done: number
-  total: number
-  className?: string
-}
-
-export function ChildProgressBar({
-  done,
-  total,
-  className,
-}: ChildProgressBarProps) {
-  const safeDone = Math.max(0, Math.min(done, total))
-  const pct = total > 0 ? Math.round((safeDone / total) * 100) : 0
-
-  return (
-    <Progress
-      value={pct}
-      className={cn("w-full min-w-[8rem] max-w-[12rem]", className)}
-      title={
-        total === 0
-          ? "No child work items"
-          : `${safeDone} of ${total} done (${pct}%)`
-      }
-    >
-      <ProgressLabel className="text-xs">
-        {total === 0 ? "No items" : `${safeDone}/${total} done`}
-      </ProgressLabel>
-      <ProgressValue className="text-xs" />
-    </Progress>
-  )
-}