@taskmark/ui 0.1.0 → 0.2.0

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

@@ -1,135 +0,0 @@
-/**
- * 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/lib/taskmark/parse-stories.ts

@@ -1,237 +0,0 @@
-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/lib/taskmark/pick-folder.ts

@@ -1,141 +0,0 @@
-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/lib/taskmark/project-label.ts

@@ -1,11 +0,0 @@
-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}`
-}

package/dist/standalone/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))
-}