@goodandready/dsh-kanban 0.2.33 → 0.2.35

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.
+ */