@soleone/pi-tasks 0.2.1

package/src/models/list-item.ts

@@ -0,0 +1,44 @@
+import { buildTaskListTextParts, type Task } from "./task.ts"
+
+export interface TaskListRowOptions {
+  maxLabelWidth?: number
+}
+
+export interface TaskListRowModel {
+  ref: string
+  label: string
+  description: string
+}
+
+export const DESCRIPTION_PART_SEPARATOR = "\u241F"
+
+function encodeDescription(meta: string, summary?: string): string {
+  return summary ? `${meta}${DESCRIPTION_PART_SEPARATOR}${summary}` : meta
+}
+
+export function decodeDescription(text: string): { meta: string; summary?: string } {
+  const [meta, summary] = text.split(DESCRIPTION_PART_SEPARATOR)
+  return { meta: meta || "", summary }
+}
+
+export function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "")
+}
+
+export function buildListRowModel(task: Task, options: TaskListRowOptions = {}): TaskListRowModel {
+  const { maxLabelWidth } = options
+  const parts = buildTaskListTextParts(task)
+  const baseLabel = `${parts.identity} ${parts.title}`
+  const visibleWidth = stripAnsi(baseLabel).length
+
+  let label = baseLabel
+  if (maxLabelWidth !== undefined && visibleWidth < maxLabelWidth) {
+    label += " ".repeat(maxLabelWidth - visibleWidth)
+  }
+
+  return {
+    ref: task.ref,
+    label,
+    description: encodeDescription(parts.meta, parts.summary),
+  }
+}

package/src/models/task.ts

@@ -0,0 +1,117 @@
+export type TaskStatus = "open" | "inProgress" | "blocked" | "deferred" | "closed"
+
+export interface Task {
+  ref: string
+  id?: string
+  title: string
+  description?: string
+  status: TaskStatus
+  priority?: string
+  taskType?: string
+  owner?: string
+  createdAt?: string
+  dueAt?: string
+  updatedAt?: string
+  dependencyCount?: number
+  dependentCount?: number
+  commentCount?: number
+}
+
+interface TaskListElements {
+  id?: string
+  title: string
+  status: string
+  type: string
+  summary?: string
+}
+
+export interface TaskListTextParts {
+  identity: string
+  title: string
+  meta: string
+  summary?: string
+}
+
+const PRIORITY_RANK_COLORS = [
+  "\x1b[38;5;196m",
+  "\x1b[38;5;208m",
+  "\x1b[38;5;34m",
+  "\x1b[38;5;33m",
+  "\x1b[38;5;245m",
+]
+
+const STATUS_SYMBOLS: Record<TaskStatus, string> = {
+  open: "○",
+  inProgress: "◑",
+  blocked: "✖",
+  deferred: "⏸",
+  closed: "✓",
+}
+
+const MUTED_TEXT = "\x1b[38;5;245m"
+const ANSI_RESET = "\x1b[0m"
+
+function priorityRank(priority: string | undefined): number | undefined {
+  if (!priority) return undefined
+  const match = priority.toLowerCase().match(/^p(\d)$/)
+  if (!match) return undefined
+  return Number(match[1])
+}
+
+export function formatTaskPriority(priority: string | undefined): string {
+  if (priority === undefined || priority === null || priority.length === 0) return "P?"
+
+  const rank = priorityRank(priority)
+  const color = rank !== undefined ? PRIORITY_RANK_COLORS[rank] ?? "" : ""
+  return `${color}${priority.toUpperCase()}${ANSI_RESET}`
+}
+
+function stripIdPrefix(id: string): string {
+  const idx = id.indexOf("-")
+  return idx >= 0 ? id.slice(idx + 1) : id
+}
+
+export function formatTaskTypeCode(taskType: string | undefined): string {
+  return (taskType || "task").slice(0, 4).padEnd(4)
+}
+
+export function toKebabCase(value: string): string {
+  return value.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase()
+}
+
+export function formatTaskStatusSymbol(status: TaskStatus): string {
+  return STATUS_SYMBOLS[status] ?? "?"
+}
+
+function firstLine(text: string | undefined): string | undefined {
+  if (!text) return undefined
+  const line = text.split(/\r?\n/)[0]?.trim()
+  return line && line.length > 0 ? line : undefined
+}
+
+function buildTaskListElements(task: Task): TaskListElements {
+  return {
+    id: task.id ? stripIdPrefix(task.id) : undefined,
+    title: task.title,
+    status: formatTaskStatusSymbol(task.status),
+    type: formatTaskTypeCode(task.taskType),
+    summary: firstLine(task.description),
+  }
+}
+
+export function buildTaskIdentityText(priority: string | undefined, idText?: string): string {
+  if (!idText) return formatTaskPriority(priority)
+  const mutedId = `${MUTED_TEXT}${idText}${ANSI_RESET}`
+  return `${formatTaskPriority(priority)} ${mutedId}`
+}
+
+export function buildTaskListTextParts(task: Task): TaskListTextParts {
+  const elements = buildTaskListElements(task)
+
+  return {
+    identity: buildTaskIdentityText(task.priority, elements.id),
+    title: elements.title,
+    meta: `${elements.status} ${elements.type}`,
+    summary: elements.summary,
+  }
+}

package/src/ui/components/blur-editor.ts

@@ -0,0 +1,78 @@
+import { Editor, Text, type Component, type EditorTheme, type Focusable } from "@mariozechner/pi-tui"
+
+interface BlurEditorFieldOptions {
+  stripTopBorder?: boolean
+  blurredBorderColor?: (str: string) => string
+  paddingX?: number
+  indentX?: number
+}
+
+export class BlurEditorField implements Component, Focusable {
+  focused = false
+  onChange?: (text: string) => void
+
+  private editor: Editor
+  private previewText: Text
+  private stripTopBorder: boolean
+  private blurredBorderColor: (str: string) => string
+  private indentX: number
+
+  constructor(tui: any, theme: EditorTheme, options: BlurEditorFieldOptions = {}) {
+    const paddingX = options.paddingX ?? 1
+
+    this.editor = new Editor(tui, theme)
+    this.editor.setPaddingX(paddingX)
+    this.previewText = new Text("", paddingX, 0)
+    this.stripTopBorder = options.stripTopBorder ?? true
+    this.blurredBorderColor = options.blurredBorderColor ?? theme.borderColor
+    this.indentX = Math.max(0, options.indentX ?? 0)
+
+    this.editor.onChange = (text: string) => {
+      this.onChange?.(text)
+    }
+  }
+
+  set disableSubmit(value: boolean) {
+    this.editor.disableSubmit = value
+  }
+
+  setText(text: string): void {
+    this.editor.setText(text)
+  }
+
+  getText(): string {
+    return this.editor.getText()
+  }
+
+  insertTextAtCursor(text: string): void {
+    this.editor.insertTextAtCursor(text)
+  }
+
+  invalidate(): void {
+    this.editor.invalidate()
+    this.previewText.invalidate()
+  }
+
+  render(width: number): string[] {
+    const innerWidth = Math.max(1, width - this.indentX)
+    const indent = " ".repeat(this.indentX)
+    const withIndent = (lines: string[]) => lines.map(line => `${indent}${line}`)
+
+    if (!this.focused) {
+      this.previewText.setText(this.editor.getText())
+      const contentLines = this.previewText.render(innerWidth)
+      const lines = contentLines.length > 0 ? contentLines : [" ".repeat(Math.max(0, innerWidth))]
+      const borderLine = this.blurredBorderColor("─".repeat(Math.max(0, innerWidth)))
+      return withIndent([...lines, borderLine])
+    }
+
+    const lines = this.editor.render(innerWidth)
+    const visibleLines = !this.stripTopBorder || lines.length <= 1 ? lines : lines.slice(1)
+    return withIndent(visibleLines)
+  }
+
+  handleInput(data: string): void {
+    if (!this.focused) return
+    this.editor.handleInput(data)
+  }
+}

package/src/ui/components/keyboard-help.ts

@@ -0,0 +1,25 @@
+export const KEYBOARD_HELP_PADDING_X = 1
+
+type ThemeLike = {
+  fg: (color: string, text: string) => string
+}
+
+export function formatKeyboardHelp(theme: ThemeLike, helpText: string): string {
+  const trimmed = helpText.trim()
+  if (trimmed.length === 0) return ""
+
+  const entries = trimmed.split(" • ").map((entry) => entry.trim()).filter(Boolean)
+
+  return entries
+    .map((entry) => {
+      const splitIdx = entry.indexOf(" ")
+      if (splitIdx === -1) {
+        return theme.fg("muted", entry)
+      }
+
+      const key = entry.slice(0, splitIdx)
+      const action = entry.slice(splitIdx + 1)
+      return `${theme.fg("muted", key)} ${theme.fg("dim", action)}`
+    })
+    .join(theme.fg("dim", " • "))
+}

package/src/ui/components/min-height.ts

@@ -0,0 +1,21 @@
+import type { Component } from "@mariozechner/pi-tui"
+
+export class MinHeightContainer implements Component {
+  constructor(private child: Component, private minHeight: number) {}
+
+  invalidate(): void {
+    this.child.invalidate()
+  }
+
+  render(width: number): string[] {
+    const lines = this.child.render(width)
+    if (lines.length >= this.minHeight) return lines
+    const padLine = " ".repeat(Math.max(0, width))
+    return [...lines, ...Array(this.minHeight - lines.length).fill(padLine)]
+  }
+
+  handleInput(data: string): void {
+    const childWithInput = this.child as Component & { handleInput?: (input: string) => void }
+    childWithInput.handleInput?.(data)
+  }
+}