@goodandready/dsh-kanban 0.2.34 → 0.2.35

package/lib/routes/task-actions.js

@@ -0,0 +1,345 @@
+/**
+ * Extended actions for task route handlers (comments, reports, checklist, triage, subtasks, PR, nudge).
+ * Zero Cyrillic in lib/ according to Issue #366.
+ */
+
+export function handleTaskChecklist({ store, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const list = Array.isArray(input?.checklist) ? input.checklist : Array.isArray(input) ? input : []
+  const updated = store.updateChecklist(task.id, list)
+  return { status: 200, body: { task: updated } }
+}
+
+/**
+ * Set completion report for task.
+ */
+export function handleTaskReport({ store, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const updated = store.setReport(task.id, input)
+  return { status: 200, body: { task: updated } }
+}
+
+/**
+ * Get comments for task.
+ */
+export function handleGetTaskComments({ task }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  return { status: 200, body: { comments: task.comments || [] } }
+}
+
+/**
+ * Add comment to task.
+ */
+export function handleAddTaskComment({ store, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const author = input?.author || 'user'
+  const role = input?.role || 'user'
+  const text = input?.text || ''
+  const updated = store.addComment(task.id, { author, role, text })
+  return { status: 200, body: { task: updated } }
+}
+
+/**
+ * Accept task review (transition to done).
+ */
+export function handleAcceptTask({ store, task }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const updated = store.acceptTask(task.id)
+  return { status: 200, body: { task: updated } }
+}
+
+/**
+ * Reject task review (return to in_progress).
+ */
+export function handleRejectTask({ store, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const reason = String(input?.reason || '').trim()
+  if (!reason) return { status: 400, body: { error: 'reason-required' } }
+  const updated = store.rejectTask(task.id, reason)
+  return { status: 200, body: { task: updated } }
+}
+
+/**
+ * Save task progress dump snapshot.
+ */
+export function handleProgressDump({ store, task, input, formatProgressDump }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const formatted = typeof input === 'string' ? input : formatProgressDump(input)
+  const updated = store.updateTask(task.id, { progressDump: formatted })
+  return { status: 200, body: { task: updated } }
+}
+
+/**
+ * Decompose a task into subtasks and make the parent an Epic.
+ */
+export async function handleTriageTask({ store, gitea, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const subtasksInput = Array.isArray(input?.subtasks) ? input.subtasks : []
+  if (subtasksInput.length === 0) {
+    return { status: 400, body: { error: 'subtasks-required' } }
+  }
+  const createGitea = input?.createGiteaIssues === true && Boolean(task.owner && task.repo && gitea)
+
+  // Convert parent into Epic
+  store.updateTask(task.id, { isEpic: true })
+
+  const created = []
+  for (const item of subtasksInput) {
+    const title = String(item?.title ?? '').trim()
+    if (!title) continue
+    const body = String(item?.body ?? '').trim()
+    let issueNumber = null
+    let issueUrl = null
+
+    if (createGitea) {
+      try {
+        const issueBody = body ? `${body}\n\nParent epic: #${task.issueNumber || task.id}` : `Parent epic: #${task.issueNumber || task.id}`
+        const giteaIssue = await gitea.createIssue({
+          owner: task.owner,
+          repo: task.repo,
+          title,
+          body: issueBody,
+        })
+        if (giteaIssue?.number) {
+          issueNumber = giteaIssue.number
+          issueUrl = giteaIssue.html_url || null
+        }
+      } catch { /* ignore gitea subtask creation failure */ }
+    }
+
+    const sub = store.createTask({
+      board: task.board || 'main',
+      column: 'backlog',
+      title,
+      body,
+      parentId: task.id,
+      owner: task.owner || null,
+      repo: task.repo || null,
+      issueNumber,
+      issueUrl,
+      labels: Array.isArray(item?.labels) ? item.labels : [],
+      workspaceId: task.workspaceId || '',
+    })
+    created.push(sub)
+  }
+
+  store.addTransition({
+    taskId: task.id,
+    fromCol: task.column,
+    toCol: task.column,
+    source: 'manual',
+    detail: `decomposed into ${created.length} subtasks (epic triage)`,
+  })
+
+  return {
+    status: 200,
+    body: {
+      epic: store.getTask(task.id),
+      subtasks: store.listSubtasks(task.id),
+      counts: store.countSubtasks(task.id),
+      createdCount: created.length,
+    },
+  }
+}
+
+/**
+ * Get subtasks of a task.
+ */
+export function handleGetSubtasks({ store, task }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  return {
+    status: 200,
+    body: {
+      subtasks: store.listSubtasks(task.id),
+      counts: store.countSubtasks(task.id),
+    },
+  }
+}
+
+/**
+ * Create a single subtask linked to a parent task.
+ */
+export async function handleCreateSubtask({ store, gitea, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const title = String(input?.title ?? '').trim()
+  if (!title) return { status: 400, body: { error: 'title-required' } }
+  const body = String(input?.body ?? '').trim()
+  let issueNumber = null
+  let issueUrl = null
+
+  if (input?.createGiteaIssue === true && task.owner && task.repo && gitea) {
+    try {
+      const issueBody = body ? `${body}\n\nParent epic: #${task.issueNumber || task.id}` : `Parent epic: #${task.issueNumber || task.id}`
+      const giteaIssue = await gitea.createIssue({
+        owner: task.owner,
+        repo: task.repo,
+        title,
+        body: issueBody,
+      })
+      if (giteaIssue?.number) {
+        issueNumber = giteaIssue.number
+        issueUrl = giteaIssue.html_url || null
+      }
+    } catch { /* ignore gitea subtask creation failure */ }
+  }
+
+  store.updateTask(task.id, { isEpic: true })
+  const sub = store.createTask({
+    board: task.board || 'main',
+    column: input?.column || 'backlog',
+    title,
+    body,
+    parentId: task.id,
+    owner: task.owner || null,
+    repo: task.repo || null,
+    issueNumber,
+    issueUrl,
+    labels: Array.isArray(input?.labels) ? input.labels : [],
+    workspaceId: task.workspaceId || '',
+  })
+  return { status: 200, body: { subtask: sub, counts: store.countSubtasks(task.id) } }
+}
+
+/**
+ * Toggle a checklist item atomically by index or text.
+ */
+export function handleToggleChecklistItem({ store, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const current = Array.isArray(task.checklist) ? [...task.checklist] : []
+  let targetIndex = -1
+
+  if (typeof input?.index === 'number' && input.index >= 0 && input.index < current.length) {
+    targetIndex = input.index
+  } else if (typeof input?.text === 'string' && input.text.trim()) {
+    const q = input.text.trim().toLowerCase()
+    targetIndex = current.findIndex((item) => {
+      const t = typeof item === 'string' ? item : item?.text
+      return typeof t === 'string' && t.toLowerCase().includes(q)
+    })
+  }
+
+  if (targetIndex === -1) {
+    return { status: 404, body: { error: 'checklist-item-not-found' } }
+  }
+
+  const item = current[targetIndex]
+  let updatedItem
+  if (typeof item === 'string') {
+    const checked = input?.checked !== undefined ? Boolean(input.checked) : true
+    updatedItem = { text: item, completed: checked, done: checked }
+  } else {
+    const isCurrentlyDone = item.completed !== undefined ? Boolean(item.completed) : Boolean(item.done)
+    const checked = input?.checked !== undefined ? Boolean(input.checked) : !isCurrentlyDone
+    updatedItem = { ...item, completed: checked, done: checked }
+  }
+  current[targetIndex] = updatedItem
+  const updated = store.updateChecklist(task.id, current)
+  return { status: 200, body: { task: updated, item: updatedItem, index: targetIndex } }
+}
+
+/**
+ * Create a Gitea Pull Request for a task.
+ */
+export async function handleCreateTaskPr({ store, gitea, task, input }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  if (!task.owner || !task.repo) {
+    return { status: 400, body: { error: 'task-no-repo' } }
+  }
+  const head = String(input?.head || task.branch || '').trim()
+  if (!head) return { status: 400, body: { error: 'branch-required' } }
+  const base = String(input?.base || 'main').trim()
+  const title = String(input?.title || task.title || `PR: ${task.title}`).trim()
+  const body = String(input?.body || (task.issueNumber ? `Closes #${task.issueNumber}` : '')).trim()
+
+  try {
+    const pr = await gitea.createPullRequest({
+      owner: task.owner,
+      repo: task.repo,
+      title,
+      body,
+      head,
+      base,
+    })
+    store.addTransition({
+      taskId: task.id,
+      fromCol: task.column,
+      toCol: task.column,
+      source: 'manual',
+      detail: `Created PR #${pr?.number || ''}: ${head} -> ${base}`,
+    })
+    return { status: 200, body: { pr, prUrl: pr?.html_url } }
+  } catch (err) {
+    return { status: 502, body: { error: 'gitea-pr-failed', detail: err?.message } }
+  }
+}
+/**
+ * Handle interactive live steering (nudge) for an active task agent (#373).
+ *
+ * @param {{
+ *   store: object,
+ *   id: string,
+ *   prompt: string,
+ *   agents?: object,
+ *   createMessage?: Function,
+ *   eventHub?: object,
+ *   now?: number
+ * }} options
+ * @returns {Promise<{ status: number, body: object }>}
+ */
+export async function handleTaskNudge({ store, id, prompt, agents, createMessage, eventHub, now = Date.now() }) {
+  if (!store || !id) return { status: 400, body: { error: 'invalid-parameters' } }
+  const task = store.getTask(id)
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+
+  const text = typeof prompt === 'string' ? prompt.trim() : ''
+  if (!text) return { status: 400, body: { error: 'prompt-required' } }
+
+  const sessionId = typeof task.sessionId === 'string' ? task.sessionId : ''
+  if (!sessionId) return { status: 409, body: { error: 'no-session' } }
+
+  let agent
+  try { agent = agents?.get?.(sessionId) } catch { agent = undefined }
+  if (!agent || typeof agent.followup !== 'function') {
+    return { status: 409, body: { error: 'session-not-live' } }
+  }
+
+  const msg = typeof createMessage === 'function'
+    ? createMessage({
+        content: [{ type: 'text', text }],
+        source: { kind: 'dsh-kanban', plugin: 'dsh-kanban', form: 'task-nudge' },
+      })
+    : { content: [{ type: 'text', text }] }
+
+  agent.followup(msg)
+
+  // Append user steering comment to task
+  if (typeof store.addComment === 'function') {
+    store.addComment(id, {
+      author: 'user',
+      role: 'user',
+      text: `[Steering Nudge] ${text}`,
+    })
+  } else if (typeof store.addTaskComment === 'function') {
+    store.addTaskComment(id, {
+      author: 'user',
+      role: 'user',
+      text: `[Steering Nudge] ${text}`,
+    })
+  }
+
+  // Broadcast change via eventHub
+  if (eventHub && typeof eventHub.broadcast === 'function') {
+    eventHub.broadcast('task:change', { id, col: task.col || task.column })
+  }
+
+  return {
+    status: 200,
+    body: {
+      success: true,
+      id,
+      sessionId,
+      prompt: text,
+      nudgedAt: now,
+    },
+  }
+}

package/lib/routes/task-worktree.js

@@ -0,0 +1,107 @@
+/**
+ * Worktree actions for task route handlers.
+ * Zero Cyrillic in lib/ according to Issue #366.
+ */
+
+export async function handleCleanupWorktree({
+  store, task, workspaceRegistry, force, cleanupTaskWorktree,
+  config, repoDir, cwdOf, env, gitRunner,
+}) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const out = await cleanupTaskWorktree({
+    store,
+    task,
+    workspaceRegistry,
+    force: force === true,
+    config,
+    repoDir,
+    cwdOf,
+    env,
+    gitRunner,
+  })
+  const status = out.status || (out.error ? (out.error === 'unfenced-worktree-path' ? 403 : 500) : 200)
+  return { status, body: out }
+}
+
+/**
+ * Get working copy diff for task.
+ */
+export async function handleTaskDiff({ task, getTaskDiff, getTaskDiffInspector }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  if (typeof getTaskDiffInspector === 'function') {
+    const inspectorResult = await getTaskDiffInspector({ worktreePath: task.worktree })
+    return { status: 200, body: inspectorResult }
+  }
+  const diffResult = await getTaskDiff({ worktreePath: task.worktree })
+  return { status: 200, body: diffResult }
+}
+
+/**
+ * Discard file changes in task worktree (#371).
+ */
+export async function handleTaskDiscard({ task, file, discardTaskFile, gitRunner }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  if (!file || typeof file !== 'string') return { status: 400, body: { error: 'file-required' } }
+  if (!task.worktree) return { status: 400, body: { error: 'no-worktree' } }
+  const result = await discardTaskFile({ worktreePath: task.worktree, file, gitRunner })
+  return { status: result.success ? 200 : 400, body: result }
+}
+
+/**
+ * Get commit list for task.
+ */
+export async function handleTaskCommits({ task, getTaskCommits, gitRunner }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const commits = await getTaskCommits({ worktreePath: task.worktree, gitRunner })
+  return { status: 200, body: { commits } }
+}
+
+/**
+ * Merge task worktree branch and transition to done.
+ */
+export async function handleTaskMerge({ store, task, targetBranch, workspaceRegistry, mergeTaskWorktree, gitRunner }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const mergeResult = await mergeTaskWorktree({
+    task,
+    targetBranch: typeof targetBranch === 'string' ? targetBranch.trim() : undefined,
+    workspaceRegistry,
+    gitRunner,
+  })
+  if (!mergeResult.success) {
+    return {
+      status: 400,
+      body: { error: mergeResult.error, detail: mergeResult.detail, files: mergeResult.files },
+    }
+  }
+  const updated = store.acceptTask(task.id)
+  store.addTransition({
+    taskId: task.id,
+    fromCol: task.column,
+    toCol: 'done',
+    source: 'manual',
+    detail: `accepted and merged branch ${task.branch} into ${mergeResult.targetBranch}`,
+  })
+  return { status: 200, body: { task: updated, merged: true, targetBranch: mergeResult.targetBranch } }
+}
+
+/**
+ * Check task worktree status (branch, dirty files, workspace).
+ */
+export async function handleTaskWorktreeStatus({ task, checkWorktreeDirty }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  const dirtyCheck = await checkWorktreeDirty({ worktreePath: task.worktree })
+  return {
+    status: 200,
+    body: {
+      worktree: task.worktree || '',
+      branch: task.branch || '',
+      workspaceId: task.workspaceId || '',
+      dirty: dirtyCheck.dirty,
+      files: dirtyCheck.files,
+    },
+  }
+}
+
+/**
+ * Update Definition of Done checklist for task.
+ */

package/lib/routes/task.js

@@ -0,0 +1,211 @@
+import { parseBody } from '../markdown.js'
+import { columnsOf, wipLimitField } from '../config.js'
+import { withPlan } from './board.js'
+
+export function parseTaskPath(pathname) {
+  const m = /^\/dsh-kanban\/task\/([^/]+)(?:\/([a-z-]+))?\/?$/.exec(pathname ?? '')
+  if (m === null) return undefined
+  return { id: decodeURIComponent(m[1]), action: m[2] }
+}
+
+/**
+ * Enrich task with parsed plan, state, and filters.
+ *
+ * Plan is pre-parsed on server because client bundle cannot import `lib/plan.js`.
+ * `liveOf` returns active agent state or undefined if session is inactive.
+ */
+
+export function applyMove({ store, config, id, column, beforeId, afterId, source = 'manual', detail = '' }) {
+  const before = store.getTask(id)
+  if (before === undefined) return { error: 'task-not-found', status: 404 }
+  if (column !== undefined && column !== null) {
+    const allowed = columnsOf(store.boardKind(before.board))
+    if (!allowed.includes(column)) {
+      return { error: 'invalid-column', status: 400 }
+    }
+  }
+  const task = store.moveTask(id, { column, beforeId, afterId })
+  if (task.column !== before.column) {
+    store.addTransition({
+      taskId: id, fromCol: before.column, toCol: task.column, source, detail,
+    })
+  }
+  const limit = wipLimitField(config, task.column)
+  const count = store.countInColumn(task.board, task.column)
+  return { task, overLimit: limit !== undefined && count > limit }
+}
+
+/** Create local board task (not linked to Gitea). */
+export function createTask({ store, input }) {
+  const title = typeof input?.title === 'string' ? input.title.trim() : ''
+  if (title === '') return { error: 'title-required', status: 400 }
+  const board = input?.board ?? 'main'
+  // Validate column against board kind; simple boards do not have deploy/cleanup.
+  const allowed = columnsOf(store.boardKind(board))
+  const column = allowed.includes(input?.column) ? input.column : 'backlog'
+  const task = store.createTask({
+    board,
+    column,
+    title,
+    body: typeof input?.body === 'string' ? input.body : '',
+    labels: Array.isArray(input?.labels) ? input.labels.filter((l) => typeof l === 'string') : [],
+  })
+  return { task }
+}
+
+/** Update card fields. Column transitions are handled via applyMove. */
+export function updateTask({ store, id, input }) {
+  const current = store.getTask(id)
+  if (current === undefined) return { error: 'task-not-found', status: 404 }
+  const patch = {}
+  if (typeof input?.title === 'string' && input.title.trim() !== '') patch.title = input.title.trim()
+  if (typeof input?.body === 'string') patch.body = input.body
+  if (Array.isArray(input?.labels)) patch.labels = input.labels.filter((l) => typeof l === 'string')
+  // Priority is local to board and not synced back to Gitea.
+  if (PRIORITIES.includes(input?.priority)) patch.priority = input.priority
+  // Deadline is local. 0 clears deadline; positive value sets it.
+  if (typeof input?.dueAt === 'number' && Number.isFinite(input.dueAt) && input.dueAt >= 0) {
+    patch.dueAt = Math.floor(input.dueAt)
+  }
+  if (typeof input?.cron === 'string') {
+    patch.cron = input.cron.trim()
+    patch.nextRunAt = patch.cron ? (computeNextRun(patch.cron) || 0) : 0
+  }
+  if (Array.isArray(input?.checklist)) patch.checklist = input.checklist
+  if (input?.report && typeof input.report === 'object') patch.report = input.report
+  if (Array.isArray(input?.comments)) patch.comments = input.comments
+  if (typeof input?.rejectReason === 'string') patch.rejectReason = input.rejectReason
+  if (typeof input?.progressDump === 'string') {
+    patch.progressDump = input.progressDump
+  }
+  if (typeof input?.permission === 'string') {
+    patch.permission = input.permission
+    if (input.permission !== current.permission) {
+      patch.permissionConfirmedAt = 0
+      patch.permissionConfirmedTier = ''
+    }
+  }
+
+  if (typeof input?.reasoningEffort === 'string') {
+    const val = input.reasoningEffort.trim().toLowerCase()
+    if (['', 'low', 'medium', 'high', 'default', 'none', 'minimal', 'thorough'].includes(val)) {
+      patch.reasoningEffort = val
+    }
+  }
+  if (typeof input?.forge === 'string') {
+    const val = input.forge.trim().toLowerCase()
+    if (val === 'github' || val === 'gitea') patch.forge = val
+  }
+  return { task: store.updateTask(id, patch) }
+}
+
+export function confirmPermission({ store, id, tier }) {
+  const task = store.getTask(id)
+  if (task === undefined) return { error: 'task-not-found', status: 404 }
+  const effectiveTier = typeof tier === 'string' && tier ? tier : (task.permission || 'default')
+  return { task: store.updateTask(id, { permissionConfirmedAt: Date.now(), permissionConfirmedTier: effectiveTier }) }
+}
+
+/** Known priority values. Empty string indicates unprioritized. */
+const PRIORITIES = ['', 'high', 'medium', 'low']
+
+/**
+ * Append note to task body.
+ * Handled on server to prevent overwriting edits made elsewhere.
+ */
+export function appendNote({ store, id, input }) {
+  const task = store.getTask(id)
+  if (task === undefined) return { error: 'task-not-found', status: 404 }
+  const note = typeof input?.text === 'string' ? input.text.trim() : ''
+  if (note === '') return { error: 'note-required', status: 400 }
+  const body = typeof task.body === 'string' ? task.body : ''
+  return { task: store.updateTask(id, { body: body === '' ? note : `${body}\n\n${note}` }) }
+}
+
+/**
+ * Archive or unarchive card.
+ * Unarchiving restores card to its original column and position.
+ */
+export function setArchived({ store, id, archived, now = Date.now() }) {
+  const task = store.getTask(id)
+  if (task === undefined) return { error: 'task-not-found', status: 404 }
+  return { task: store.setArchived(id, archived ? now : 0) }
+}
+
+/** Query archived tasks list. */
+export function listArchive({ store }) {
+  return { tasks: store.listArchived() }
+}
+
+/**
+ * Assign task or clear assignment.
+ * Empty login unassigns the task.
+ *
+ * @returns {{task: object}|{error: string, status: number}}
+ */
+export function assignTask({ store, id, login }) {
+  const task = store.getTask(id)
+  if (task === undefined) return { error: 'task-not-found', status: 404 }
+  const who = typeof login === 'string' ? login.trim() : ''
+  if (who === (task.assignee ?? '')) return { task }
+  store.updateTask(id, { assignee: who })
+  store.addTransition({
+    taskId: id,
+    fromCol: task.column,
+    toCol: task.column,
+    source: 'manual',
+    detail: who === '' ? 'unassigned' : `assigned: ${who}`,
+  })
+  return { task: store.getTask(id) }
+}
+
+export function deleteTask({ store, id }) {
+  if (store.getTask(id) === undefined) return { error: 'task-not-found', status: 404 }
+  store.deleteTask(id)
+  return { ok: true }
+}
+
+/**
+ * Parse task markdown body into structured block elements.
+ * Done on server so client bundle does not need markdown parser.
+ */
+/**
+ * Board metrics: WIP distribution and stale tasks.
+ *
+ * @returns {{columns: object[], done: object, stale: object[], tasks: number}}
+ */
+
+export function canRevive(task, live) {
+  if (task?.stalled) return true
+  const has = typeof task?.sessionId === 'string' && task.sessionId !== ''
+  return has && (live === undefined || live === null)
+}
+
+export function taskBody({ store, id }) {
+  const task = store.getTask(id)
+  if (task === undefined) return { error: 'task-not-found', status: 404 }
+  return { blocks: parseBody(task.body) }
+}
+
+export function taskLog({ store, id }) {
+  if (store.getTask(id) === undefined) return { error: 'task-not-found', status: 404 }
+  return { transitions: store.listTransitions(id) }
+}
+
+/** Find task associated with session; absence is normal response. */
+export function taskBySession({ store, sessionId, agents }) {
+  const task = store.findTaskBySession(sessionId)
+  if (task === undefined) return { task: null }
+  let live
+  try { live = agents?.get?.(sessionId) } catch { live = undefined }
+  // Board kind returned with task so UI displays matching column choices.
+  return {
+    task,
+    columns: columnsOf(store.boardKind(task.board)),
+    canRevive: canRevive(task, live),
+  }
+}
+
+/**
+ * Export full board snapshot for backup or migration.
+ */