@taskmark/ui 0.1.0

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

@@ -0,0 +1,135 @@
+/**
+ * Shared markdown section / table / checklist parsers for work item detail views.
+ */
+
+export function extractMarkdownBody(raw: string): string {
+  const source = raw.replace(/^(---\r?\n[\s\S]*?\S)---(\r?\n)/, "$1\n---$2")
+  const match = /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/.exec(source)
+  if (!match) return raw.trim()
+  return source.slice(match[0].length).trim()
+}
+
+/** Split body into `## Heading` → content map (heading text without ##). */
+export function extractSections(body: string): Record<string, string> {
+  const sections: Record<string, string> = {}
+  const lines = body.split(/\r?\n/)
+  let current: string | null = null
+  const buf: string[] = []
+
+  const flush = () => {
+    if (current == null) return
+    sections[current] = buf.join("\n").trim()
+    buf.length = 0
+  }
+
+  for (const line of lines) {
+    const heading = /^##\s+(.+?)\s*$/.exec(line)
+    if (heading) {
+      flush()
+      current = heading[1].trim()
+      continue
+    }
+    if (current != null) buf.push(line)
+  }
+  flush()
+  return sections
+}
+
+export function getSection(
+  sections: Record<string, string>,
+  ...names: string[]
+): string {
+  const lower = Object.fromEntries(
+    Object.entries(sections).map(([k, v]) => [k.toLowerCase(), v])
+  )
+  for (const name of names) {
+    const found = lower[name.toLowerCase()]
+    if (found != null && found !== "") return found
+  }
+  return ""
+}
+
+export type ChecklistItem = {
+  text: string
+  checked: boolean
+}
+
+export function parseChecklist(markdown: string): ChecklistItem[] {
+  const items: ChecklistItem[] = []
+  for (const line of markdown.split(/\r?\n/)) {
+    const m = /^\s*[-*]\s+\[([ xX])\]\s+(.*)$/.exec(line)
+    if (!m) continue
+    items.push({
+      checked: m[1].toLowerCase() === "x",
+      text: m[2].trim(),
+    })
+  }
+  return items
+}
+
+export type MarkdownTable = {
+  headers: string[]
+  rows: string[][]
+}
+
+/** Parse the first GitHub-flavored markdown table in a section. */
+export function parseMarkdownTable(markdown: string): MarkdownTable | null {
+  const lines = markdown
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter(Boolean)
+
+  for (let i = 0; i < lines.length - 1; i++) {
+    if (!lines[i].startsWith("|")) continue
+    const headerCells = splitRow(lines[i])
+    const sep = lines[i + 1]
+    if (!sep || !/^\|?\s*:?-{3,}/.test(sep)) continue
+
+    const rows: string[][] = []
+    for (let j = i + 2; j < lines.length; j++) {
+      if (!lines[j].startsWith("|")) break
+      const cells = splitRow(lines[j])
+      if (cells.every((c) => c === "" || c === "—" || c === "-")) continue
+      rows.push(cells)
+    }
+    return { headers: headerCells, rows }
+  }
+  return null
+}
+
+function splitRow(line: string): string[] {
+  let s = line.trim()
+  if (s.startsWith("|")) s = s.slice(1)
+  if (s.endsWith("|")) s = s.slice(0, -1)
+  return s.split("|").map((c) => c.trim())
+}
+
+export function tableRowsAsObjects(
+  table: MarkdownTable | null
+): Record<string, string>[] {
+  if (!table) return []
+  const keys = table.headers.map((h) => h.toLowerCase())
+  return table.rows.map((row) => {
+    const obj: Record<string, string> = {}
+    keys.forEach((key, i) => {
+      obj[key] = row[i] ?? ""
+    })
+    return obj
+  })
+}
+
+export function cell(
+  row: Record<string, string>,
+  ...keys: string[]
+): string {
+  for (const key of keys) {
+    const found = row[key.toLowerCase()]
+    if (found != null && found !== "") return found
+  }
+  // fuzzy: find header containing key
+  for (const key of keys) {
+    const hit = Object.entries(row).find(([k]) => k.includes(key.toLowerCase()))
+    if (hit) return hit[1]
+  }
+  return ""
+}

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

@@ -0,0 +1,237 @@
+import fs from "node:fs"
+import path from "node:path"
+
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+import type {
+  EpicStoryList,
+  StoryParseError,
+  StorySummary,
+} from "@/lib/taskmark/story-types"
+import {
+  asNumberOrNull,
+  asString,
+  asStringArray,
+  extractFrontmatter,
+} from "@/lib/taskmark/frontmatter"
+import { asContributorList } from "@/lib/taskmark/identity"
+import { readTimingFields } from "@/lib/taskmark/timing"
+import { progressUnderStory } from "@/lib/taskmark/count-leaves"
+
+type EpicFolder = {
+  dirName: string
+  epicFile: string
+  id: string
+  title: string
+}
+
+function readEpicFolderMeta(
+  epicDir: string,
+  dirName: string
+): EpicFolder | null {
+  const epicFile = path.join(epicDir, "epic.md")
+  if (!fs.existsSync(epicFile)) return null
+
+  let raw: string
+  try {
+    raw = fs.readFileSync(epicFile, "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, epicFile, id, title }
+}
+
+/** Resolve the epic folder directory for a given epic id under a board. */
+export function findEpicFolder(
+  boardPath: string,
+  epicId: string
+): EpicFolder | null {
+  const epicsDir = path.join(boardPath, "epics")
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(epicsDir, { withFileTypes: true })
+  } catch {
+    return null
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
+    const meta = readEpicFolderMeta(path.join(epicsDir, entry.name), entry.name)
+    if (meta?.id === epicId) return meta
+  }
+  return null
+}
+
+function listStoryMarkdownFiles(epicDir: string): string[] {
+  const storiesDir = path.join(epicDir, "stories")
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(storiesDir, { withFileTypes: true })
+  } catch {
+    return []
+  }
+
+  const files: string[] = []
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
+    const storyFile = path.join(storiesDir, entry.name, "story.md")
+    if (fs.existsSync(storyFile)) {
+      files.push(storyFile)
+    }
+  }
+  return files.sort()
+}
+
+function parseStoryFile(
+  filePath: string,
+  project: DiscoveredProject,
+  epicId: string
+): { story?: StorySummary; error?: StoryParseError } {
+  let raw: string
+  try {
+    raw = fs.readFileSync(filePath, "utf8")
+  } catch (err) {
+    return {
+      error: {
+        filePath,
+        projectId: project.id,
+        projectName: project.name,
+        epicId,
+        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,
+        epicId,
+        message:
+          err instanceof Error ? err.message : "Invalid YAML frontmatter",
+      },
+    }
+  }
+
+  if (!frontmatter) {
+    return {
+      error: {
+        filePath,
+        projectId: project.id,
+        projectName: project.name,
+        epicId,
+        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,
+        epicId,
+        message: "Frontmatter requires id and title",
+      },
+    }
+  }
+
+  const progress = progressUnderStory(project.boardPath, epicId, id)
+
+  return {
+    story: {
+      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),
+      epic: asString(frontmatter.epic, epicId),
+      workItemCount: progress.total,
+      doneWorkItemCount: progress.done,
+      filePath,
+      project: {
+        id: project.id,
+        name: project.name,
+        projectPath: project.projectPath,
+        boardPath: project.boardPath,
+      },
+    },
+  }
+}
+
+/**
+ * Parse all stories under a selected epic for a project's board root.
+ * Returns an empty story list (with no errors) when the epic folder is missing.
+ */
+export function parseStoriesForEpic(
+  project: DiscoveredProject,
+  epicId: string
+): EpicStoryList {
+  const folder = findEpicFolder(project.boardPath, epicId)
+  if (!folder) {
+    return {
+      project,
+      epicId,
+      epicTitle: null,
+      stories: [],
+      errors: [
+        {
+          filePath: path.join(project.boardPath, "epics"),
+          projectId: project.id,
+          projectName: project.name,
+          epicId,
+          message: `Epic ${epicId} not found under this board`,
+        },
+      ],
+    }
+  }
+
+  const epicDir = path.join(project.boardPath, "epics", folder.dirName)
+  const files = listStoryMarkdownFiles(epicDir)
+  const stories: StorySummary[] = []
+  const errors: StoryParseError[] = []
+
+  for (const filePath of files) {
+    const result = parseStoryFile(filePath, project, epicId)
+    if (result.story) stories.push(result.story)
+    if (result.error) errors.push(result.error)
+  }
+
+  stories.sort((a, b) => a.id.localeCompare(b.id))
+
+  return {
+    project,
+    epicId,
+    epicTitle: folder.title || null,
+    stories,
+    errors,
+  }
+}

package/dist/standalone/dist/standalone/dist/standalone/dist/standalone/dist/standalone/lib/taskmark/pick-folder.ts

@@ -0,0 +1,141 @@
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+
+const execFileAsync = promisify(execFile)
+
+export type PickFolderResult =
+  | { ok: true; path: string }
+  | { ok: false; cancelled: true }
+  | { ok: false; cancelled: false; error: string }
+
+function trimTrailingSlash(p: string): string {
+  if (p.length > 1 && (p.endsWith("/") || p.endsWith("\\"))) {
+    return p.slice(0, -1)
+  }
+  return p
+}
+
+async function pickFolderDarwin(): Promise<PickFolderResult> {
+  try {
+    const { stdout } = await execFileAsync(
+      "osascript",
+      [
+        "-e",
+        'POSIX path of (choose folder with prompt "Select Taskmark master folder")',
+      ],
+      { timeout: 120_000 }
+    )
+    const path = trimTrailingSlash(stdout.trim())
+    if (!path) {
+      return { ok: false, cancelled: true }
+    }
+    return { ok: true, path }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    // User cancelled the dialog (AppleScript error -128)
+    if (
+      message.includes("User canceled") ||
+      message.includes("User cancelled") ||
+      message.includes("-128")
+    ) {
+      return { ok: false, cancelled: true }
+    }
+    if (
+      err &&
+      typeof err === "object" &&
+      "stderr" in err &&
+      String((err as { stderr?: unknown }).stderr).includes("-128")
+    ) {
+      return { ok: false, cancelled: true }
+    }
+    return {
+      ok: false,
+      cancelled: false,
+      error: `Folder picker failed: ${message}`,
+    }
+  }
+}
+
+async function pickFolderLinux(): Promise<PickFolderResult> {
+  try {
+    const { stdout } = await execFileAsync(
+      "zenity",
+      ["--file-selection", "--directory", "--title=Select Taskmark master folder"],
+      { timeout: 120_000 }
+    )
+    const path = trimTrailingSlash(stdout.trim())
+    if (!path) return { ok: false, cancelled: true }
+    return { ok: true, path }
+  } catch (err) {
+    const code =
+      err && typeof err === "object" && "code" in err
+        ? (err as { code?: number | string }).code
+        : undefined
+    if (code === 1) return { ok: false, cancelled: true }
+    const message = err instanceof Error ? err.message : String(err)
+    if (message.includes("ENOENT")) {
+      return {
+        ok: false,
+        cancelled: false,
+        error:
+          "Folder picker needs zenity on Linux, or paste a path instead.",
+      }
+    }
+    return {
+      ok: false,
+      cancelled: false,
+      error: `Folder picker failed: ${message}`,
+    }
+  }
+}
+
+async function pickFolderWindows(): Promise<PickFolderResult> {
+  const script = `
+Add-Type -AssemblyName System.Windows.Forms
+$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+$dialog.Description = 'Select Taskmark master folder'
+$dialog.ShowNewFolderButton = $false
+if ($dialog.ShowDialog() -ne [System.Windows.Forms.DialogResult]::OK) { exit 1 }
+Write-Output $dialog.SelectedPath
+`
+  try {
+    const { stdout } = await execFileAsync(
+      "powershell.exe",
+      ["-NoProfile", "-Command", script],
+      { timeout: 120_000 }
+    )
+    const path = trimTrailingSlash(stdout.trim())
+    if (!path) return { ok: false, cancelled: true }
+    return { ok: true, path }
+  } catch (err) {
+    const code =
+      err && typeof err === "object" && "code" in err
+        ? (err as { code?: number | string }).code
+        : undefined
+    if (code === 1) return { ok: false, cancelled: true }
+    const message = err instanceof Error ? err.message : String(err)
+    return {
+      ok: false,
+      cancelled: false,
+      error: `Folder picker failed: ${message}`,
+    }
+  }
+}
+
+/** Open a native OS folder dialog and return an absolute path (local server only). */
+export async function pickFolderNative(): Promise<PickFolderResult> {
+  switch (process.platform) {
+    case "darwin":
+      return pickFolderDarwin()
+    case "win32":
+      return pickFolderWindows()
+    case "linux":
+      return pickFolderLinux()
+    default:
+      return {
+        ok: false,
+        cancelled: false,
+        error: `Folder picker is not supported on ${process.platform}. Paste a path instead.`,
+      }
+  }
+}

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

@@ -0,0 +1,11 @@
+import type { DiscoveredProject } from "@/lib/taskmark/types"
+
+/** Label for dropdown; disambiguate when names collide. */
+export function projectOptionLabel(
+  project: DiscoveredProject,
+  all: DiscoveredProject[]
+): string {
+  const sameName = all.filter((p) => p.name === project.name)
+  if (sameName.length <= 1) return project.name
+  return `${project.name} — ${project.projectPath}`
+}