@marcomigozzi/trailhead 0.13.0 → 0.14.0

package/plugins/trailhead/tests/work-state-view.test.ts

@@ -0,0 +1,86 @@
+import { expect, test } from 'claude-code/testing'
+
+import { fit, parseWorkState, pipeline, sameValue, statusLine } from '../hooks/mod/work-state-view'
+
+const valid = {
+  map: 198,
+  ticket: 203,
+  title: 'Status entry',
+  step: 'plan',
+  auto: false,
+  autoDone: 0,
+  session: 's1',
+  updatedAt: '2026-10-11T00:00:00.000Z',
+}
+const parse = (over: Record<string, unknown>) => parseWorkState(JSON.stringify({ ...valid, ...over }))
+
+test('parseWorkState accepts a full state and rejects what has no ticket or step', () => {
+  expect(parse({})).toEqual(valid)
+  expect(parseWorkState('{not json')).toBeNull()
+  expect(parseWorkState('[1]')).toBeNull()
+  expect(parseWorkState('null')).toBeNull()
+  expect(parse({ ticket: 0 })).toBeNull()
+  expect(parse({ ticket: 'x' })).toBeNull()
+  expect(parse({ step: 'nope' })).toBeNull()
+  expect(parse({ step: undefined })).toBeNull()
+})
+
+test('parseWorkState defaults autoDone and normalises invalid optional fields', () => {
+  const { autoDone: _drop, ...old } = valid
+  expect(parseWorkState(JSON.stringify(old))?.autoDone).toBe(0)
+  expect(parse({ autoDone: -1 })?.autoDone).toBe(0)
+  expect(parse({ autoDone: 1.5 })?.autoDone).toBe(0)
+  expect(parse({ autoDone: 4, auto: true })).toMatchObject({ auto: true, autoDone: 4 })
+  expect(parse({ map: 'zz' })?.map).toBeNull()
+  expect(parse({ map: null })?.map).toBeNull()
+  expect(parse({ title: 42 })?.title).toBeNull()
+  expect(parse({ title: '  a\nb  ' })?.title).toBe('a b')
+  expect(parse({ title: '   ' })?.title).toBeNull()
+  expect(parse({ auto: 'yes' })?.auto).toBe(false)
+  expect(parse({ session: 7 })?.session).toBeNull()
+  expect(parse({ session: null })?.session).toBeNull()
+})
+
+test('statusLine builds the entry for each shape', () => {
+  const s = parse({})
+  expect(statusLine(s, false)).toBe('map #198 · #203 Status entry · plan')
+  expect(statusLine(parse({ map: null }), false)).toBe('whiteboard · #203 Status entry · plan')
+  expect(statusLine(parse({ title: null }), false)).toBe('map #198 · #203 · plan')
+  expect(statusLine(parse({ auto: true, autoDone: 3 }), false)).toBe(
+    'map #198 · #203 Status entry · plan · auto 3 done',
+  )
+  expect(statusLine(s, true)).toBe('map #198 · #203 Status entry · plan · orphaned, resume?')
+  expect(statusLine(parse({ auto: true, autoDone: 1 }), true)).toBe(
+    'map #198 · #203 Status entry · plan · auto 1 done · orphaned, resume?',
+  )
+  expect(statusLine(null, false)).toBeUndefined()
+  expect(statusLine(null, true)).toBeUndefined()
+})
+
+test('pipeline marks the stages for each step', () => {
+  const status = (step: string) => pipeline(step).stages.map(s => s.status)
+  expect(pipeline('plan').stages.map(s => s.name)).toEqual(['discuss', 'plan', 'execute', 'verify'])
+  expect(status('discuss')).toEqual(['current', 'todo', 'todo', 'todo'])
+  expect(status('plan')).toEqual(['done', 'current', 'todo', 'todo'])
+  expect(status('execute')).toEqual(['done', 'done', 'current', 'todo'])
+  expect(status('verify')).toEqual(['done', 'done', 'done', 'current'])
+  expect(status('resolve')).toEqual(['done', 'done', 'done', 'done'])
+  expect(status('paused')).toEqual(['todo', 'todo', 'todo', 'todo'])
+  expect(pipeline('paused').isPaused).toBe(true)
+  expect(pipeline('plan').isPaused).toBe(false)
+})
+
+test('sameValue compares by content, not by key order or reference', () => {
+  expect(sameValue({ a: 1, b: null }, { b: null, a: 1 })).toBe(true)
+  expect(sameValue(parse({}), parse({}))).toBe(true)
+  expect(sameValue(parse({}), parse({ step: 'execute' }))).toBe(false)
+  expect(sameValue(null, null)).toBe(true)
+  expect(sameValue(null, parse({}))).toBe(false)
+})
+
+test('fit cuts with an ellipsis by code point and leaves a short text whole', () => {
+  expect(fit('short', 10)).toBe('short')
+  expect(fit('abcdef', 4)).toBe('abc…')
+  expect(fit('abcdef', 1)).toBe('…')
+  expect(fit('a' + '\u{1F680}'.repeat(5), 3)).toBe('a\u{1F680}…')
+})

package/plugins/trailhead/types/index.d.ts

@@ -0,0 +1,69 @@
+// Typed contract of the trailhead mod: the shared work state (see #200).
+export type WorkState = {
+  map: number | null
+  ticket: number | null
+  title: string | null
+  step: string | null
+  auto: boolean
+  autoDone: number
+  session: string | null
+  updatedAt: string | null
+}
+
+// The latched system-prompt section: the key it was built for and its text (null: no section).
+export type PromptSnapshot = { key: string; text: string | null }
+
+// The map pane (#208): what the last `gh` read of the active map gave.
+export type TicketType = 'decision' | 'research' | 'prototype' | 'build' | 'bug' | 'task'
+export type TicketState = 'frontier' | 'in-progress' | 'blocked'
+
+export type PaneTicket = {
+  number: number
+  title: string
+  type: TicketType | null
+  state: TicketState
+  assignees: readonly string[]
+  url: string
+}
+
+// One open map of the repo, as the maps list shows it.
+export type MapSummary = { number: number; title: string }
+
+export type MapInfo = { number: number; title: string; destination: string | null; url: string }
+
+// One ticket of the map's history, in epoch ms; `closedAt` null while open.
+export type BurndownIssue = { openedAt: number; closedAt: number | null; isRemoved: boolean }
+// `isCapped`: gh returned as many rows as it was asked for, so the oldest tickets may be missing.
+export type BurndownHistory = { issues: readonly BurndownIssue[]; isCapped: boolean }
+
+// `map` and `tickets` keep the last good read through a failure; `error` is its reason (null: healthy).
+// `history` has its own last good read and time (`historyAt`): a history-only failure keeps it.
+export type MapPaneData = {
+  map: MapInfo | null
+  tickets: readonly PaneTicket[]
+  unverifiedCount: number
+  isCapped: boolean
+  // The repo's open maps (empty until a first good read, then the last good one).
+  maps: readonly MapSummary[]
+  history: BurndownHistory | null
+  historyAt: number | null
+  fetchedAt: number | null
+  error: string | null
+  isLoading: boolean
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    trailhead: {
+      workState: WorkState | null
+      isOrphaned: boolean
+      promptSnapshot: PromptSnapshot | null
+      mapPane: MapPaneData
+      activeMap: number | null
+      // The map the pane shows when it is not the active one; null follows the active map.
+      viewedMap: number | null
+      pendingWork: number | null
+      paneAutoOpened: boolean
+    }
+  }
+}