@soleone/pi-tasks 0.2.1

package/src/controllers/list.ts

@@ -0,0 +1,208 @@
+import { Key, matchesKey } from "@mariozechner/pi-tui"
+
+export type ListIntent =
+  | { type: "cancel" }
+  | { type: "searchStart" }
+  | { type: "searchCancel" }
+  | { type: "searchApply" }
+  | { type: "searchBackspace" }
+  | { type: "searchAppend"; value: string }
+  | { type: "moveSelection"; delta: number }
+  | { type: "work" }
+  | { type: "edit" }
+  | { type: "toggleStatus" }
+  | { type: "setPriority"; priority: string }
+  | { type: "scrollDescription"; delta: number }
+  | { type: "toggleType" }
+  | { type: "create" }
+  | { type: "insert" }
+  | { type: "delegate" }
+
+export interface ListControllerState {
+  searching: boolean
+  filtered: boolean
+  allowSearch: boolean
+  allowPriority: boolean
+  ctrlQ: string
+  priorities: string[]
+  priorityHotkeys?: Record<string, string>
+}
+
+type ShortcutContext = "default" | "search"
+
+interface ShortcutDefinition {
+  context: ShortcutContext
+  help?: string | ((state: ListControllerState) => string)
+  showInHelp?: (state: ListControllerState) => boolean
+  match: (data: string, state: ListControllerState) => boolean
+  intent: (data: string, state: ListControllerState) => ListIntent
+}
+
+function parsePriorityKey(
+  data: string,
+  priorities: string[],
+  priorityHotkeys?: Record<string, string>,
+): string | null {
+  if (data.length !== 1) return null
+
+  const hotkeyPriority = priorityHotkeys?.[data]
+  if (hotkeyPriority && priorities.includes(hotkeyPriority)) return hotkeyPriority
+
+  const rank = parseInt(data, 10)
+  if (isNaN(rank) || rank < 1 || rank > priorities.length) return null
+  return priorities[rank - 1] ?? null
+}
+
+function buildPriorityHelpText(priorities: string[], priorityHotkeys?: Record<string, string>): string {
+  const hotkeyKeys = priorityHotkeys ? Object.keys(priorityHotkeys).sort((a, b) => a.localeCompare(b)) : []
+  if (hotkeyKeys.length > 0) {
+    return `${hotkeyKeys.join("/")} priority`
+  }
+
+  if (priorities.length === 0) return "priority"
+  if (priorities.length === 1) return "1 priority"
+  return `1-${priorities.length} priority`
+}
+
+function isPrintable(data: string): boolean {
+  return data.length === 1 && data.charCodeAt(0) >= 32 && data.charCodeAt(0) < 127
+}
+
+const MOVE_KEYS: Record<string, number> = {
+  w: -1,
+  W: -1,
+  s: 1,
+  S: 1,
+}
+
+const SCROLL_KEYS: Record<string, number> = {
+  j: 1,
+  k: -1,
+}
+
+const SHORTCUT_DEFINITIONS: ShortcutDefinition[] = [
+  {
+    context: "search",
+    match: (data, state) => data === state.ctrlQ,
+    intent: () => ({ type: "cancel" }),
+  },
+  {
+    context: "search",
+    help: "esc cancel",
+    match: (data) => matchesKey(data, Key.escape),
+    intent: () => ({ type: "searchCancel" }),
+  },
+  {
+    context: "search",
+    help: "enter apply",
+    match: (data) => matchesKey(data, Key.enter),
+    intent: () => ({ type: "searchApply" }),
+  },
+  {
+    context: "search",
+    match: (data) => matchesKey(data, Key.backspace),
+    intent: () => ({ type: "searchBackspace" }),
+  },
+  {
+    context: "search",
+    help: "type to search",
+    match: (data) => isPrintable(data),
+    intent: (data) => ({ type: "searchAppend", value: data }),
+  },
+  {
+    context: "default",
+    help: "w/s navigate",
+    match: (data) => data in MOVE_KEYS,
+    intent: (data) => ({ type: "moveSelection", delta: MOVE_KEYS[data] ?? 1 }),
+  },
+  {
+    context: "default",
+    help: "enter work",
+    match: (data) => matchesKey(data, Key.enter),
+    intent: () => ({ type: "work" }),
+  },
+  {
+    context: "default",
+    help: "e edit",
+    match: (data) => data === "e" || data === "E" || matchesKey(data, Key.right),
+    intent: () => ({ type: "edit" }),
+  },
+  {
+    context: "default",
+    help: (state) => buildPriorityHelpText(state.priorities, state.priorityHotkeys),
+    showInHelp: (state) => state.allowPriority,
+    match: (data, state) => state.allowPriority && parsePriorityKey(data, state.priorities, state.priorityHotkeys) !== null,
+    intent: (data, state) => ({
+      type: "setPriority",
+      priority: parsePriorityKey(data, state.priorities, state.priorityHotkeys) ?? state.priorities[0] ?? "",
+    }),
+  },
+  {
+    context: "default",
+    help: "f find",
+    showInHelp: (state) => state.allowSearch,
+    match: (data, state) => state.allowSearch && (data === "f" || data === "F"),
+    intent: () => ({ type: "searchStart" }),
+  },
+  {
+    context: "default",
+    match: (data) => data === " ",
+    intent: () => ({ type: "toggleStatus" }),
+  },
+  {
+    context: "default",
+    match: (data) => data in SCROLL_KEYS,
+    intent: (data) => ({ type: "scrollDescription", delta: SCROLL_KEYS[data] ?? 1 }),
+  },
+  {
+    context: "default",
+    help: "t type",
+    match: (data) => data === "t" || data === "T",
+    intent: () => ({ type: "toggleType" }),
+  },
+  {
+    context: "default",
+    help: "c create",
+    match: (data) => data === "c" || data === "C",
+    intent: () => ({ type: "create" }),
+  },
+  {
+    context: "default",
+    help: "tab insert",
+    match: (data) => matchesKey(data, Key.tab),
+    intent: () => ({ type: "insert" }),
+  },
+  {
+    context: "default",
+    match: (data, state) => data === state.ctrlQ,
+    intent: () => ({ type: "cancel" }),
+  },
+]
+
+export function resolveListIntent(data: string, state: ListControllerState): ListIntent {
+  const context: ShortcutContext = state.searching ? "search" : "default"
+  for (const shortcut of SHORTCUT_DEFINITIONS) {
+    if (shortcut.context !== context) continue
+    if (shortcut.match(data, state)) return shortcut.intent(data, state)
+  }
+  return { type: "delegate" }
+}
+
+export function buildListPrimaryHelpText(state: ListControllerState): string {
+  const context: ShortcutContext = state.searching ? "search" : "default"
+  const parts = SHORTCUT_DEFINITIONS
+    .filter(s => s.context === context)
+    .filter(s => !!s.help)
+    .filter(s => (s.showInHelp ? s.showInHelp(state) : true))
+    .map(s => (typeof s.help === "function" ? s.help(state) : s.help as string))
+
+  if (context === "default") {
+    parts.push(state.filtered ? "esc clear filter" : "esc cancel")
+  }
+
+  return parts.join(" • ")
+}
+
+export function buildListSecondaryHelpText(): string {
+  return "space status • j/k scroll"
+}

package/src/controllers/show.ts

@@ -0,0 +1,81 @@
+import type { TaskStatus } from "../models/task.ts"
+
+export type FormFocus = "nav" | "title" | "desc"
+export type FormMode = "edit" | "create"
+
+export interface FormDraft {
+  title: string
+  description: string
+  status: TaskStatus
+  priority: string | undefined
+  taskType: string | undefined
+}
+
+type HeaderStatusColor = "dim" | "accent" | "warning"
+
+export interface HeaderStatus {
+  message: string
+  icon?: string
+  color: HeaderStatusColor
+}
+
+const FOCUS_LABELS: Record<Exclude<FormFocus, "nav">, string> = {
+  title: "Title",
+  desc: "Description",
+}
+
+export function normalizeDraft(draft: FormDraft): FormDraft {
+  return {
+    ...draft,
+    title: draft.title.trim(),
+  }
+}
+
+export function isSameDraft(a: FormDraft, b: FormDraft): boolean {
+  const left = normalizeDraft(a)
+  const right = normalizeDraft(b)
+  return (
+    left.title === right.title &&
+    left.description === right.description &&
+    left.status === right.status &&
+    left.priority === right.priority &&
+    left.taskType === right.taskType
+  )
+}
+
+export function getHeaderStatus(
+  saveIndicator: "saving" | "saved" | "error" | undefined,
+  focus: FormFocus,
+): HeaderStatus | undefined {
+  if (saveIndicator === "saving") return { message: "Saving…", icon: "⟳", color: "dim" }
+  if (saveIndicator === "saved") return { message: "Saved", icon: "✓", color: "accent" }
+  if (saveIndicator === "error") return { message: "Save failed", color: "warning" }
+  if (focus === "title" || focus === "desc") return { message: `Editing ${FOCUS_LABELS[focus].toLowerCase()}`, color: "accent" }
+  return undefined
+}
+
+export function buildPrimaryHelpText(focus: FormFocus): string {
+  if (focus === "title") return "enter save • tab description • esc back"
+  if (focus === "desc") return "enter newline • tab save • esc back"
+  return "tab title • enter save • esc/q back • ctrl+x close"
+}
+
+function buildPriorityHelpText(priorities: string[], priorityHotkeys?: Record<string, string>): string {
+  const hotkeyKeys = priorityHotkeys ? Object.keys(priorityHotkeys).sort((a, b) => a.localeCompare(b)) : []
+  if (hotkeyKeys.length > 0) {
+    return `${hotkeyKeys.join("/")} priority`
+  }
+
+  if (priorities.length === 0) return "priority"
+  if (priorities.length === 1) return "1 priority"
+  return `1-${priorities.length} priority`
+}
+
+export function buildSecondaryHelpText(
+  focus: FormFocus,
+  priorities: string[],
+  priorityHotkeys?: Record<string, string>,
+): string {
+  if (focus !== "nav") return ""
+  return `space status • ${buildPriorityHelpText(priorities, priorityHotkeys)} • t type`
+}

package/src/extension.ts

@@ -0,0 +1,358 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent"
+import initializeAdapter from "./backend/resolver.ts"
+import type { Task, TaskStatus } from "./models/task.ts"
+import { buildTaskWorkPrompt, serializeTask } from "./lib/task-serialization.ts"
+import { showTaskList } from "./ui/pages/list.ts"
+import { showTaskForm } from "./ui/pages/show.ts"
+import type { TaskUpdate } from "./backend/api.ts"
+
+const CTRL_Q = "\x11"
+
+function parsePriorityKey(
+  data: string,
+  priorities: string[],
+  priorityHotkeys?: Record<string, string>,
+): string | null {
+  if (data.length !== 1) return null
+
+  const hotkeyPriority = priorityHotkeys?.[data]
+  if (hotkeyPriority && priorities.includes(hotkeyPriority)) return hotkeyPriority
+
+  const rank = parseInt(data, 10)
+  if (isNaN(rank) || rank < 1 || rank > priorities.length) return null
+  return priorities[rank - 1] ?? null
+}
+
+function cycleStatus(current: TaskStatus, statusMap: Record<string, string>): TaskStatus {
+  const statusCycle = Object.keys(statusMap) as TaskStatus[]
+  if (statusCycle.length === 0) return "open"
+  const idx = statusCycle.indexOf(current)
+  if (idx === -1) return statusCycle[0]
+  return statusCycle[(idx + 1) % statusCycle.length]
+}
+
+function cycleTaskType(current: string | undefined, taskTypes: string[]): string {
+  if (taskTypes.length === 0) return "task"
+  const normalized = current || taskTypes[0]
+  const idx = taskTypes.indexOf(normalized)
+  if (idx === -1) return taskTypes[0]
+  return taskTypes[(idx + 1) % taskTypes.length]
+}
+
+function defaultPriority(priorities: string[]): string | undefined {
+  if (priorities.length === 0) return undefined
+  return priorities[Math.floor(priorities.length / 2)]
+}
+
+function defaultTaskType(taskTypes: string[]): string | undefined {
+  return taskTypes[0]
+}
+
+function hasUniqueValues(values: string[]): boolean {
+  return new Set(values).size === values.length
+}
+
+function validateBackendConfiguration(backend: {
+  id: string
+  statusMap: Record<string, string>
+  taskTypes: string[]
+  priorities: string[]
+  priorityHotkeys?: Record<string, string>
+}): void {
+  const statusKeys = Object.keys(backend.statusMap)
+  if (statusKeys.length === 0) {
+    throw new Error(`Invalid backend config (${backend.id}): statusMap must not be empty`)
+  }
+
+  if (!statusKeys.includes("open") || !statusKeys.includes("closed")) {
+    throw new Error(`Invalid backend config (${backend.id}): statusMap must include open and closed`)
+  }
+
+  if (backend.taskTypes.length === 0) {
+    throw new Error(`Invalid backend config (${backend.id}): taskTypes must not be empty`)
+  }
+
+  if (!hasUniqueValues(backend.taskTypes)) {
+    throw new Error(`Invalid backend config (${backend.id}): taskTypes must be unique`)
+  }
+
+  if (backend.priorities.length < 3 || backend.priorities.length > 5) {
+    throw new Error(`Invalid backend config (${backend.id}): priorities must contain 3 to 5 values`)
+  }
+
+  if (!hasUniqueValues(backend.priorities)) {
+    throw new Error(`Invalid backend config (${backend.id}): priorities must be unique`)
+  }
+
+  if (backend.priorityHotkeys) {
+    for (const [key, priority] of Object.entries(backend.priorityHotkeys)) {
+      if (key.length !== 1) {
+        throw new Error(`Invalid backend config (${backend.id}): priority hotkey keys must be a single character`)
+      }
+
+      if (!backend.priorities.includes(priority)) {
+        throw new Error(`Invalid backend config (${backend.id}): priority hotkey ${key} points to unsupported priority ${priority}`)
+      }
+    }
+  }
+}
+
+interface EditTaskResult {
+  updatedTask: Task | null
+  closeList: boolean
+}
+
+function buildTaskUpdate(previous: Task, next: {
+  title: string
+  description: string
+  status: TaskStatus
+  priority: string | undefined
+  taskType: string | undefined
+}): TaskUpdate {
+  const update: TaskUpdate = {}
+
+  const nextTitle = next.title.trim()
+  if (nextTitle !== previous.title.trim()) {
+    update.title = nextTitle
+  }
+
+  if (next.description !== (previous.description ?? "")) {
+    update.description = next.description
+  }
+
+  if (next.status !== previous.status) {
+    update.status = next.status
+  }
+
+  if (next.priority !== previous.priority && next.priority !== undefined) {
+    update.priority = next.priority
+  }
+
+  if (next.taskType !== previous.taskType) {
+    update.taskType = next.taskType || "task"
+  }
+
+  return update
+}
+
+function hasTaskUpdate(update: TaskUpdate): boolean {
+  return Object.keys(update).length > 0
+}
+
+function applyDraftToTask(
+  task: Task,
+  draft: {
+    title: string
+    description: string
+    status: TaskStatus
+    priority: string | undefined
+    taskType: string | undefined
+  },
+): Task {
+  const nextTask: Task = {
+    ...task,
+    title: draft.title.trim(),
+    description: draft.description,
+    status: draft.status,
+  }
+
+  if (draft.priority !== undefined) {
+    nextTask.priority = draft.priority
+  } else {
+    delete nextTask.priority
+  }
+
+  if (draft.taskType !== undefined) {
+    nextTask.taskType = draft.taskType
+  } else {
+    delete nextTask.taskType
+  }
+
+  return nextTask
+}
+
+export default function registerExtension(pi: ExtensionAPI) {
+  const backend = initializeAdapter(pi)
+  validateBackendConfiguration(backend)
+
+  const nextStatus = (status: TaskStatus): TaskStatus => cycleStatus(status, backend.statusMap)
+  const nextTaskType = (current: string | undefined): string => cycleTaskType(current, backend.taskTypes)
+  const nextPriorityFromKey = (data: string): string | null => parsePriorityKey(
+    data,
+    backend.priorities,
+    backend.priorityHotkeys,
+  )
+
+  async function listTasks(): Promise<Task[]> {
+    return backend.list()
+  }
+
+  async function showTask(ref: string): Promise<Task> {
+    return backend.show(ref)
+  }
+
+  function needsTaskDetailsForEdit(task: Task): boolean {
+    return task.description === undefined
+  }
+
+  async function getTaskForEdit(ref: string, fromList?: Task): Promise<Task> {
+    if (!fromList) return showTask(ref)
+    if (needsTaskDetailsForEdit(fromList)) return showTask(ref)
+    return { ...fromList }
+  }
+
+  async function updateTask(ref: string, update: TaskUpdate): Promise<void> {
+    await backend.update(ref, update)
+  }
+
+  async function editTask(ctx: ExtensionCommandContext, ref: string, fromList?: Task): Promise<EditTaskResult> {
+    let task = await getTaskForEdit(ref, fromList)
+
+    const formResult = await showTaskForm(ctx, {
+      mode: "edit",
+      subtitle: "Edit",
+      task,
+      ctrlQ: CTRL_Q,
+      cycleStatus: nextStatus,
+      cycleTaskType: nextTaskType,
+      parsePriorityKey: nextPriorityFromKey,
+      priorities: backend.priorities,
+      priorityHotkeys: backend.priorityHotkeys,
+      onSave: async (draft) => {
+        const update = buildTaskUpdate(task, {
+          title: draft.title,
+          description: draft.description,
+          status: draft.status,
+          priority: draft.priority,
+          taskType: draft.taskType,
+        })
+
+        if (!hasTaskUpdate(update)) return false
+
+        await updateTask(ref, update)
+        task = applyDraftToTask(task, {
+          title: draft.title,
+          description: draft.description,
+          status: draft.status,
+          priority: draft.priority,
+          taskType: draft.taskType,
+        })
+        return true
+      },
+    })
+
+    return {
+      updatedTask: task,
+      closeList: formResult.action === "close_list",
+    }
+  }
+
+  async function createTask(ctx: ExtensionCommandContext): Promise<Task | null> {
+    let createdTask: Task | null = null
+
+    await showTaskForm(ctx, {
+      mode: "create",
+      subtitle: "Create",
+      task: {
+        ref: "new",
+        title: "",
+        description: "",
+        status: "open",
+        priority: defaultPriority(backend.priorities),
+        taskType: defaultTaskType(backend.taskTypes),
+      },
+      ctrlQ: CTRL_Q,
+      cycleStatus: nextStatus,
+      cycleTaskType: nextTaskType,
+      parsePriorityKey: nextPriorityFromKey,
+      priorities: backend.priorities,
+      priorityHotkeys: backend.priorityHotkeys,
+      onSave: async (draft) => {
+        const title = draft.title.trim()
+        if (title.length === 0) {
+          throw new Error("Title is required")
+        }
+
+        if (!createdTask) {
+          createdTask = await backend.create({
+            title,
+            description: draft.description,
+            status: draft.status,
+            priority: draft.priority,
+            taskType: draft.taskType,
+          })
+          return true
+        }
+
+        const update = buildTaskUpdate(createdTask, {
+          title,
+          description: draft.description,
+          status: draft.status,
+          priority: draft.priority,
+          taskType: draft.taskType,
+        })
+
+        if (!hasTaskUpdate(update)) return false
+
+        await updateTask(createdTask.ref, update)
+        createdTask = applyDraftToTask(createdTask, {
+          title,
+          description: draft.description,
+          status: draft.status,
+          priority: draft.priority,
+          taskType: draft.taskType,
+        })
+        return true
+      },
+    })
+
+    return createdTask
+  }
+
+  async function browseTasks(ctx: ExtensionCommandContext): Promise<void> {
+    const pageTitle = "Tasks"
+    const backendLabel = backend.id
+
+    try {
+      backend.invalidateCache?.()
+      ctx.ui.setStatus("tasks", "Loading…")
+      const tasks = await listTasks()
+      ctx.ui.setStatus("tasks", undefined)
+
+      await showTaskList(ctx, {
+        title: pageTitle,
+        subtitle: backendLabel,
+        tasks,
+        ctrlQ: CTRL_Q,
+        priorities: backend.priorities,
+        priorityHotkeys: backend.priorityHotkeys,
+        cycleStatus: nextStatus,
+        cycleTaskType: nextTaskType,
+        onUpdateTask: updateTask,
+        onWork: (task) => pi.sendUserMessage(buildTaskWorkPrompt(task)),
+        onInsert: (task) => ctx.ui.pasteToEditor(`${serializeTask(task)} `),
+        onEdit: (ref, task) => editTask(ctx, ref, task),
+        onCreate: () => createTask(ctx),
+      })
+    } catch (e) {
+      ctx.ui.setStatus("tasks", undefined)
+      ctx.ui.notify(e instanceof Error ? e.message : String(e), "error")
+    }
+  }
+
+  pi.registerCommand("tasks", {
+    description: "Open task list",
+    handler: async (_rawArgs, ctx) => {
+      if (!ctx.hasUI) return
+      await browseTasks(ctx)
+    },
+  })
+
+  pi.registerShortcut("ctrl+x", {
+    description: "Open task list",
+    handler: async (ctx) => {
+      if (!ctx.hasUI) return
+      await browseTasks(ctx as ExtensionCommandContext)
+    },
+  })
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent"
+
+import registerExtension from "./extension.ts"
+
+export default function (pi: ExtensionAPI) {
+  registerExtension(pi)
+}

package/src/lib/task-serialization.ts

@@ -0,0 +1,45 @@
+import type { Task } from "../models/task.ts"
+import { toKebabCase } from "../models/task.ts"
+
+export function serializeTask(task: Task): string {
+  const parts = [
+    `title="${task.title}"`,
+    `status=${toKebabCase(task.status)}`,
+    `priority=${task.priority ?? "unknown"}`,
+    `type=${task.taskType || "task"}`,
+  ]
+
+  if (task.id) {
+    parts.unshift(`id=${task.id}`)
+  }
+
+  const description = task.description?.trim()
+  if (description) {
+    parts.push(`description="${description.replaceAll("\n", "\\n")}"`)
+  }
+
+  if (task.dueAt) {
+    parts.push(`due="${task.dueAt}"`)
+  }
+
+  return `task(${parts.join(", ")})`
+}
+
+export function buildTaskWorkPrompt(task: Task): string {
+  const leadLine = task.id
+    ? `Work on task ${task.id}: ${task.title}`
+    : `Work on task: ${task.title}`
+
+  const lines = [
+    leadLine,
+    "",
+    `Status: ${toKebabCase(task.status)}`,
+    `Priority: ${task.priority ?? "unknown"}`,
+  ]
+
+  if (task.description && task.description.trim()) {
+    lines.push("", "Context:", task.description.trim())
+  }
+
+  return lines.join("\n")
+}