@veewo/dsh-better-tasks 0.0.0-stage → 0.4.5

package/src/task-model.mjs

@@ -0,0 +1,235 @@
+export const SIDEBAR_CHILD_SLOTS = Object.freeze([
+  'sidebar.brand.mark',
+  'sidebar.brand.name',
+  'sidebar.panellist',
+  'sidebar.panellist.actions',
+  'sidebar.workspaces',
+  'sidebar.settings',
+  'sidebar.footer.action',
+  'sidebar.session.action',
+])
+
+export function createSidebarChildDeclarations({ iconsInFactory = false } = {}) {
+  return Object.fromEntries(SIDEBAR_CHILD_SLOTS.filter(name => !iconsInFactory || name !== 'sidebar.panellist').map((name) => [name, {
+    kind: name === 'sidebar.session.action' ? 'hoc'
+      : name === 'sidebar.panellist' || name === 'sidebar.panellist.actions' || name === 'sidebar.footer.action' ? 'list' : 'single',
+    scope: 'root',
+  }]))
+}
+
+export const ACTIVITY_RANGE_DAYS = Object.freeze({
+  all: null,
+  '1d': 1,
+  '3d': 3,
+  '7d': 7,
+  '14d': 14,
+})
+
+const DAY_MS = 24 * 60 * 60 * 1000
+
+function compareStableRecency(left, right) {
+  if (left.updatedAt !== right.updatedAt) return right.updatedAt - left.updatedAt
+  const leftId = String(left.id)
+  const rightId = String(right.id)
+  return leftId < rightId ? -1 : leftId > rightId ? 1 : 0
+}
+
+export function beforeIdForTaskDrop(orderedIds, overId, half) {
+  if (half !== 'before' && half !== 'after') throw new Error(`unsupported drop half: ${half}`)
+  const index = orderedIds.indexOf(overId)
+  if (index === -1) throw new Error(`unknown drop target: ${overId}`)
+  return half === 'before' ? overId : orderedIds[index + 1] ?? null
+}
+
+export function indexWorkspacesBySession(workspaces) {
+  const index = new Map()
+  for (const workspace of workspaces) {
+    for (const sessionId of workspace.sessionIds) {
+      if (!index.has(sessionId)) index.set(sessionId, workspace)
+    }
+  }
+  return index
+}
+
+export async function loadProjectAppearances(fetchImpl, url = '/api/project-appearance') {
+  try {
+    const response = await fetchImpl(url, { cache: 'no-store' })
+    if (!response.ok) throw new Error(`appearance request failed: ${response.status}`)
+    const payload = await response.json()
+    if (!Array.isArray(payload.items) || !Array.isArray(payload.icons)) {
+      throw new Error('appearance response is missing items or icons')
+    }
+    return Object.freeze({
+      status: 'ready',
+      items: payload.items,
+      icons: payload.icons,
+      colorKeys: Array.isArray(payload.colorKeys) ? payload.colorKeys : [],
+    })
+  } catch (error) {
+    return Object.freeze({
+      status: 'unavailable',
+      items: [],
+      icons: [],
+      colorKeys: [],
+      error: String(error?.message ?? error),
+    })
+  }
+}
+
+export function summarizeGoal(value) {
+  if (value === undefined) return Object.freeze({ availability: 'unknown' })
+  if (value === null || value.goal.phase === 'complete') return Object.freeze({ availability: 'none' })
+  const reason = value.goal.blockedReason
+  return Object.freeze({
+    availability: 'ready',
+    id: value.goal.id,
+    phase: value.goal.phase,
+    objective: value.goal.objective,
+    roundsStarted: value.roundsStarted,
+    maxGoalRounds: value.goal.maxGoalRounds,
+    blockedReason: reason === undefined ? undefined : Object.freeze({ code: reason.code, message: reason.message }),
+  })
+}
+
+export function summarizeTodos(value) {
+  if (value === undefined) return Object.freeze({ availability: 'unknown' })
+  if (value === null) return Object.freeze({ availability: 'none' })
+  const counts = { pending: 0, inProgress: 0, completed: 0, total: value.length }
+  const items = value.map((todo) => {
+    if (todo.status === 'pending') counts.pending += 1
+    else if (todo.status === 'in_progress') counts.inProgress += 1
+    else if (todo.status === 'completed') counts.completed += 1
+    return Object.freeze({ content: todo.content, status: todo.status })
+  })
+  return Object.freeze({ availability: 'ready', ...counts, items: Object.freeze(items) })
+}
+
+/** Warning is presentation only: keep idle actions available for stopped tasks. */
+export function taskExecutionWarning(summary, pendingInteraction, connectionState, catalogReady = true) {
+  if (connectionState === 'disconnected' || connectionState === 'connecting') return { kind: 'disconnected', detail: '' }
+  if (pendingInteraction != null || summary.running || !catalogReady) return null
+  const execution = summary.projectionValues?.betterTasksExecution
+  if (execution == null) return null // No capability / not yet hydrated is not failure.
+  if (execution.phase === 'running') return { kind: 'interrupted', detail: '' }
+  if (execution.phase !== 'ended') return null
+  const kind = execution.outcome
+  if (!['error', 'aborted', 'interrupted', 'max-tokens'].includes(kind)) return null
+  return { kind, detail: typeof execution.detail === 'string' ? execution.detail : '' }
+}
+
+export function summarizeSession(summary, pendingInteraction) {
+  if (pendingInteraction !== undefined) {
+    return Object.freeze({ status: 'block', interaction: pendingInteraction.kind })
+  }
+  if (summary.running) return Object.freeze({ status: 'running' })
+  return Object.freeze({ status: 'idle' })
+}
+
+/**
+ * Fold native live status through native subagent catalog edges, not fork ancestry.
+ * Status events win over older list rows, including explicit false. Walk upward
+ * once so grandchildren count even while their direct parent is idle. No retain,
+ * polling, execution ownership, or inference from a persisted open turn.
+ */
+export function runningSessionTreeIds(list, sessionStatuses = new Map()) {
+  const rows = list.byId
+  const projections = list.projectionsBySession ?? {}
+  const parents = new Map()
+  const ids = new Set([...Object.keys(rows), ...Object.keys(projections), ...sessionStatuses.keys()])
+  for (const id of ids) {
+    const catalog = projections[id]?.values?.subagentCatalog ?? rows[id]?.projectionValues?.subagentCatalog
+    if (!Array.isArray(catalog)) continue
+    for (const child of catalog) {
+      ids.add(child.id)
+      if (!parents.has(child.id)) parents.set(child.id, new Set())
+      parents.get(child.id).add(id)
+    }
+  }
+  const running = new Set([...ids].filter((id) => (sessionStatuses.get(id)?.running ?? rows[id]?.running) === true))
+  const queue = [...running]
+  for (let index = 0; index < queue.length; index += 1) {
+    for (const parent of parents.get(queue[index]) ?? []) {
+      if (running.has(parent)) continue // Also bounds malformed cyclic catalogs.
+      running.add(parent)
+      queue.push(parent)
+    }
+  }
+  return running
+}
+
+function projectTask(summary, currentId, pendingInteraction) {
+  const projections = summary.projectionValues
+  return Object.freeze({
+    id: summary.id,
+    title: summary.displayTitle ?? summary.title ?? String(summary.id),
+    cwd: summary.cwd,
+    updatedAt: summary.updatedAt,
+    current: summary.id === currentId,
+    goal: summarizeGoal(projections?.goal),
+    todos: summarizeTodos(projections?.todos),
+    session: summarizeSession(summary, pendingInteraction),
+  })
+}
+
+/** Match the native 0.2 browser's main-view selection, not Agent running state. */
+export function currentTaskSessionId(list, panelActive = false) {
+  if (panelActive) return undefined
+  const rows = Object.values(list.byId)
+  // 0.2's catalog removed list.current; retention is updated as the view switches.
+  // Never fall back to an obsolete current id once the new contract is present.
+  if (rows.some((row) => Object.hasOwn(row, 'retainedBy'))) {
+    return rows.find((row) => (row.retainedBy?.mainView ?? 0) > 0)?.id
+  }
+  return list.current // Retained 0.1.5 compatibility only.
+}
+
+/** Derive task cards in the exact Host-owned pin order. */
+export function derivePinnedTasks({ list, pinnedSessionIds, pendingInteractions = new Map(), panelActive = false, sessionStatuses = new Map() }) {
+  if (!Array.isArray(pinnedSessionIds)) throw new Error('pinnedSessionIds must be an array')
+  const seen = new Set()
+  const tasks = []
+  const currentId = currentTaskSessionId(list, panelActive)
+  const runningIds = runningSessionTreeIds(list, sessionStatuses)
+  for (const id of pinnedSessionIds) {
+    if (seen.has(id)) continue
+    seen.add(id)
+    const summary = list.byId[id]
+    if (summary === undefined || summary.blank || summary.origin === 'subagent') continue
+    tasks.push(projectTask({ ...summary, running: runningIds.has(id) }, currentId, pendingInteractions.get(id)))
+  }
+  return tasks
+}
+
+/**
+ * Legacy bounded recent projection retained for compatibility tests and rollback.
+ * The task UI no longer uses it as membership or ordering authority.
+ */
+export function deriveRecentTasks({
+  list,
+  archivedSessionIds = [],
+  pendingInteractions = new Map(),
+  activityRange = 'all',
+  now = Date.now(),
+  limit = 10,
+}) {
+  if (!Object.hasOwn(ACTIVITY_RANGE_DAYS, activityRange)) {
+    throw new Error(`unsupported activity range: ${activityRange}`)
+  }
+  if (!Number.isSafeInteger(limit) || limit < 0) throw new Error('limit must be a non-negative safe integer')
+
+  const archived = new Set(archivedSessionIds)
+  const days = ACTIVITY_RANGE_DAYS[activityRange]
+  const cutoff = days === null ? Number.NEGATIVE_INFINITY : now - days * DAY_MS
+  const visible = []
+
+  for (const id of list.ids) {
+    const summary = list.byId[id]
+    if (summary === undefined) continue
+    if (summary.blank || summary.origin === 'subagent' || archived.has(summary.id)) continue
+    if (summary.updatedAt < cutoff) continue
+    visible.push(summary)
+  }
+
+  visible.sort(compareStableRecency)
+  return visible.slice(0, limit).map((summary) => projectTask(summary, list.current, pendingInteractions.get(summary.id)))
+}

package/src/task-preferences.mjs

@@ -0,0 +1,139 @@
+export const TASK_SETTINGS_NAMESPACE = 'better-tasks-ui'
+// 0.2 dsh-settings.describe emits ns=entry.options.id and write resolves that
+// same options.id (lib/index.js:443,502 in 0.2.0-rc.2). Inspect's qualified
+// loader id (include:better-tasks-ui) is NOT the settings namespace.
+export const TASK_SETTINGS_ENTRY_ID = TASK_SETTINGS_NAMESPACE
+export const TASK_DETAIL_FONT_MIN = 11
+export const TASK_DETAIL_FONT_MAX = 16
+export const TASK_COLUMN_LAYOUTS = Object.freeze(['auto', 'single', 'double'])
+export const TASK_TITLE_EMPHASES = Object.freeze(['project', 'task'])
+/** Sidebar body the browser shows: the native session list or the task swimlane. */
+export const TASK_SIDEBAR_VIEWS = Object.freeze(['native', 'tasks'])
+export const DEFAULT_TASK_PREFERENCES = Object.freeze({
+  detailFontSize: 13,
+  defaultTodoExpanded: false,
+  defaultGoalExpanded: false,
+  defaultFinalExpanded: true,
+  defaultInputExpanded: false,
+  columnLayout: 'auto',
+  titleEmphasis: 'task',
+  sidebarView: 'native',
+})
+
+const FIELDS = new Set(Object.keys(DEFAULT_TASK_PREFERENCES))
+
+export function decodeTaskPreferences(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const detailFontSize = value.detailFontSize
+  const columnLayout = value.columnLayout
+  const titleEmphasis = value.titleEmphasis === undefined ? DEFAULT_TASK_PREFERENCES.titleEmphasis : value.titleEmphasis
+  if (!TASK_TITLE_EMPHASES.includes(titleEmphasis)) return undefined
+  // Absent reads as the default, like titleEmphasis: rows written before this
+  // preference existed must keep decoding.
+  const sidebarView = value.sidebarView === undefined ? DEFAULT_TASK_PREFERENCES.sidebarView : value.sidebarView
+  if (!TASK_SIDEBAR_VIEWS.includes(sidebarView)) return undefined
+  if (!Number.isInteger(detailFontSize) || detailFontSize < TASK_DETAIL_FONT_MIN || detailFontSize > TASK_DETAIL_FONT_MAX) return undefined
+  if (!TASK_COLUMN_LAYOUTS.includes(columnLayout)) return undefined
+  for (const field of ['defaultTodoExpanded', 'defaultGoalExpanded', 'defaultFinalExpanded', 'defaultInputExpanded']) {
+    if (typeof value[field] !== 'boolean') return undefined
+  }
+  return Object.freeze({
+    detailFontSize,
+    defaultTodoExpanded: value.defaultTodoExpanded,
+    defaultGoalExpanded: value.defaultGoalExpanded,
+    defaultFinalExpanded: value.defaultFinalExpanded,
+    defaultInputExpanded: value.defaultInputExpanded,
+    columnLayout,
+    titleEmphasis,
+    sidebarView,
+  })
+}
+
+function fallbackSnapshot() {
+  return Object.freeze({
+    status: 'unavailable',
+    value: DEFAULT_TASK_PREFERENCES,
+    revision: undefined,
+    writable: false,
+    mode: 'memory',
+  })
+}
+
+export function createTaskPreferencesStore() {
+  let snapshot = fallbackSnapshot()
+  let scope
+  let unsubscribe
+  const listeners = new Set()
+
+  const publish = (next) => {
+    if (snapshot.status === next.status && snapshot.value === next.value && snapshot.revision === next.revision && snapshot.writable === next.writable && snapshot.mode === next.mode) return
+    snapshot = Object.freeze(next)
+    for (const listener of listeners) listener()
+  }
+
+  const sync = () => {
+    if (scope === undefined) return publish(fallbackSnapshot())
+    const source = scope.getSnapshot()
+    const decoded = decodeTaskPreferences(source.value)
+    publish({
+      status: source.status,
+      value: decoded ?? DEFAULT_TASK_PREFERENCES,
+      revision: source.revision,
+      // ConfigFormController may report the document's writable=true even when
+      // this entry is absent. Never write defaults into an unserved namespace.
+      writable: source.status === 'ready' && decoded !== undefined && source.writable === true,
+      mode: source.mode,
+    })
+  }
+
+  const disconnect = () => {
+    unsubscribe?.()
+    unsubscribe = undefined
+    scope = undefined
+    sync()
+  }
+
+  return Object.freeze({
+    source: Object.freeze({
+      getSnapshot: () => snapshot,
+      subscribe(listener) {
+        listeners.add(listener)
+        return () => listeners.delete(listener)
+      },
+    }),
+    connect(nextScope) {
+      disconnect()
+      scope = nextScope
+      sync()
+      unsubscribe = nextScope.subscribe(sync)
+      return () => {
+        if (scope !== nextScope) return
+        disconnect()
+      }
+    },
+    set(field, value) {
+      if (!FIELDS.has(field)) return Promise.reject(new TypeError(`unknown Better Tasks setting: ${String(field)}`))
+      if (scope === undefined || !snapshot.writable) return Promise.reject(new Error('Better Tasks settings are not writable'))
+      const optimistic = decodeTaskPreferences({ ...snapshot.value, [field]: value })
+      if (optimistic === undefined) return Promise.reject(new TypeError(`invalid Better Tasks setting: ${field}`))
+      const writeScope = scope
+      publish({ ...snapshot, value: optimistic })
+      const rejected = (error) => {
+        if (scope === writeScope) sync()
+        throw error
+      }
+      let result
+      try {
+        result = writeScope.set(field, value)
+      } catch (error) {
+        return Promise.reject(error).catch(rejected)
+      }
+      return Promise.resolve(result).then((accepted) => {
+        // 0.2 resolves false after a rejected mutation and recovery read; it does
+        // not reject. Legacy settings scopes may resolve void on success.
+        if (accepted === false) throw new Error('Better Tasks settings write was rejected by Host')
+        return accepted
+      }).catch(rejected)
+    },
+  })
+}