dsh-error-atlas 0.11.2 → 0.11.26

package/test/run.mjs

@@ -31,7 +31,7 @@ function eq(name, actual, expected) {
 }
 
 // ── harness ────────────────────────────────────────────────────────────────
-async function bootHost(home) {
+async function bootHost(home, config = {}) {
   process.env.DSH_HOME = home
   const mod = await import('file://' + HOST.replace(/\\/g, '/') + '?t=' + Math.random())
   const handlers = new Map()
@@ -75,7 +75,7 @@ async function bootHost(home) {
         fn()
       },
     },
-    {},
+    config,
   )
   const fire = (event, ...args) => {
     for (const fn of handlers.get(event) || []) fn(...args)
@@ -198,7 +198,7 @@ async function retroSection() {
   const prompt = host.sections.find((entry) => entry.name === 'error-atlas:retrospective')
   eq('the prompt section keeps its order slot', prompt && prompt.order, 300)
   const promptText = prompt && typeof prompt.text === 'function' ? prompt.text({}) : prompt && prompt.text
-  check('the prompt section is short', promptText && promptText.length < 400, 'length=' + (promptText && promptText.length))
+  check('the prompt section is short', promptText && promptText.length < 500, 'length=' + (promptText && promptText.length))
   eq('the atlas_retro tool is registered', host.tools.filter((tool) => tool.name === 'atlas_retro').length, 1)
 }
 
@@ -355,12 +355,16 @@ async function clientSection() {
   section('client')
   let React
   let renderToStaticMarkup
-  // React comes from the running DSH profile, so the client checks exercise the same
-  // renderer the panel does. The lookup is derived, never absolute: DSH_HOME wins, then
-  // the conventional home, and a missing profile only skips this section.
+  // React comes from the running DSH profile when there is one, so the client checks
+  // exercise the same renderer the panel does; a checkout with its own devDependencies
+  // (CI) falls back to the package's node_modules. The lookup is derived, never absolute:
+  // DSH_HOME wins, then the conventional home, then the two local node_modules roots,
+  // and a machine without any of them only skips this section.
   const homes = []
   if (process.env.DSH_HOME) homes.push(join(process.env.DSH_HOME, 'profiles', 'node_modules') + '/')
   homes.push(join(homedir(), '.dsh', 'profiles', 'node_modules') + '/')
+  homes.push(join(process.cwd(), 'node_modules') + '/')
+  homes.push(join(import.meta.dirname, '..', 'node_modules') + '/')
   for (const dir of homes) {
     if (!existsSync(dir)) continue
     try {
@@ -379,9 +383,11 @@ async function clientSection() {
   }
 
   const RAW = readFileSync(CLIENT, 'utf8')
+  // Windows checkouts may carry CRLF (git core.autocrlf), so the seam must not depend on
+  // a literal line ending; match the slot list itself instead.
   const SRC = RAW.replace(
-    "    return {\n      inject: ['slots'],",
-    "    return {\n      __debug: { createRenderer, isHubNode, withDev },\n      inject: ['slots'],",
+    /( *)return \{\r?\n( *)inject: \['slots'\],/,
+    '$1return {\n$2__debug: { createRenderer, isHubNode, withDev, cloudRadiusFor },\n$2inject: [\'slots\'],',
   ).replace('useState(() => withDev(null))', 'useState(() => withDev(window.__ATLAS_SEED__))')
   check('the test seam is present', SRC.includes('__debug'))
 
@@ -521,6 +527,12 @@ async function clientSection() {
   check('a clean tag uses the calm bar', html.includes('dshea-board-fill is-clean'))
   check('the canvas is mounted', html.includes('dshea-canvas'))
   check('the label switch renders', html.includes('dshea-caption'))
+  check('the size dial renders', html.includes('dshea-size') && html.includes('大小'))
+  check('the glow dial renders', html.includes('dshea-halo') && html.includes('光晕'))
+  check('the pulse dial renders', html.includes('dshea-flow') && html.includes('光点'))
+  check('the spread dial renders', html.includes('dshea-spread') && html.includes('间距'))
+  check('the dials live in the look popover', html.includes('dshea-style') && html.includes('外观'))
+  eq('the look popover carries all five dials', (html.match(/type="range"/g) || []).length, 5)
   check('the label switch is not the label overlay', !html.includes('dshea-btn dshea-labels'))
   check('the header draws no fill', /\.dshea-header \{[^}]*background: transparent;/.test(RAW))
   check('the paused hint is not shown by default', !html.includes('已暂停'))
@@ -551,6 +563,110 @@ async function clientSection() {
   renderer.setLabels(true)
   check('the label switch brings the captions back', labelElement.style.display === '' && state.showLabels === true)
   check('a program is a hub', module.__debug.isHubNode('project') === true)
+
+  // Colour filters: switching a kind off zeroes its alpha, switching a wire role off
+  // zeroes that role's link alpha, and clearing the filter restores both.
+  eq('both colour filters render', (html.match(/class="dshea-colors"/g) || []).length, 2)
+  check('the colour filters carry chips', (html.match(/class="dshea-chip/g) || []).length >= 10)
+  const exitIdx = state.nodes.findIndex((node) => node.kind === 'exit')
+  const retroIdx = state.nodes.findIndex((node) => node.kind === 'retro')
+  check('the fixture carries an exit failure', exitIdx >= 0, String(exitIdx))
+  renderer.setFilters(['exit'], [])
+  windowStub.__raf(1032)
+  check('a filtered-out kind goes dark', state.alpha[exitIdx] === 0, String(state.alpha[exitIdx]))
+  check('other kinds stay lit', state.alpha[retroIdx] > 0.1, String(state.alpha[retroIdx]))
+  renderer.setFilters([], [])
+  windowStub.__raf(1048)
+  check('clearing the kind filter restores the node', state.alpha[exitIdx] > 0.5, String(state.alpha[exitIdx]))
+  const lessonLink = state.linkRoles.findIndex((role) => role === 'lesson' || role === 'stale')
+  check('a lesson wire is labelled', lessonLink >= 0, String(lessonLink))
+  const lessonAlpha = state.linkAlpha[lessonLink * 2]
+  renderer.setFilters([], ['lesson', 'stale'])
+  check('a filtered-out wire goes dark', state.linkAlpha[lessonLink * 2] === 0, String(state.linkAlpha[lessonLink * 2]))
+  renderer.setFilters([], [])
+  check('clearing the wire filter restores it', state.linkAlpha[lessonLink * 2] === lessonAlpha)
+
+  // A program is a satellite, not another node in the ball: it has to settle outside
+  // the error cloud while its links keep it tethered to what it produced.
+  let tick = 2000
+  for (let f = 0; f < 120; f += 1) {
+    tick += 16.7
+    if (typeof windowStub.__raf !== 'function') break
+    const frame = windowStub.__raf
+    windowStub.__raf = null
+    frame(tick)
+  }
+  const radiusOf = (id) => {
+    const i = index.get(id)
+    return Math.hypot(state.pos[i * 3], state.pos[i * 3 + 1], state.pos[i * 3 + 2])
+  }
+  const projectRadius = radiusOf('p:app')
+  const maxErrorRadius = Math.max(radiusOf('e:e1'), radiusOf('e:e2'))
+  check('a program orbits outside the cloud', projectRadius > 45, projectRadius.toFixed(1))
+  check('a program clears the errors it came from', projectRadius > maxErrorRadius + 4, projectRadius.toFixed(1) + ' vs ' + maxErrorRadius.toFixed(1))
+  check('the tether survives the orbit', state.links.some((link) => link.a === index.get('e:e1') && link.b === index.get('p:app')))
+
+  // The stage grows with the atlas: 2400 failures need a wider cloud, or the islands
+  // collapse back into one ball.
+  check('a small atlas keeps the old stage', module.__debug.cloudRadiusFor(240) === 34, String(module.__debug.cloudRadiusFor(240)))
+  check('a large atlas widens the stage', module.__debug.cloudRadiusFor(2400) > 3 * 34, module.__debug.cloudRadiusFor(2400).toFixed(1))
+
+  // Session windows are islands: each failure must settle nearest its own window, not the
+  // window of another conversation that happened to suffer the same tool.
+  const islandPayload = {
+    generatedAt: now,
+    stats: { total: 4, distinct: 4, shown: 7, matched: 4, truncated: 0, muted: 0, sessions: 2, tools: 2, projects: 0, retro: 0, stale: 0, dev: 0, byKind: {} },
+    prefs: { minCount: 1, ignore: [], prompt: true, inject: true },
+    trend: payload.trend,
+    nodes: [
+      { id: 'root:dsh', kind: 'root', label: 'DSH', count: 4 },
+      { id: 'sessionhub:sess-a', kind: 'sessionhub', label: 'SESSION aaaa', count: 2 },
+      { id: 'sessionhub:sess-b', kind: 'sessionhub', label: 'SESSION bbbb', count: 2 },
+      { id: 'e:a1', kind: 'tool', label: 'edit', name: 'edit', message: 'a1', count: 1, sessions: ['sess-a'] },
+      { id: 'e:a2', kind: 'exit', label: 'pwsh', name: 'pwsh', message: 'a2', count: 1, sessions: ['sess-a'] },
+      { id: 'e:b1', kind: 'tool', label: 'edit', name: 'edit', message: 'b1', count: 1, sessions: ['sess-b'] },
+      { id: 'e:b2', kind: 'exit', label: 'pwsh', name: 'pwsh', message: 'b2', count: 1, sessions: ['sess-b'] },
+    ],
+    links: [
+      { s: 'e:a1', t: 'root:dsh' },
+      { s: 'e:a2', t: 'root:dsh' },
+      { s: 'e:b1', t: 'root:dsh' },
+      { s: 'e:b2', t: 'root:dsh' },
+      { s: 'e:a1', t: 'sessionhub:sess-a' },
+      { s: 'e:a2', t: 'sessionhub:sess-a' },
+      { s: 'e:b1', t: 'sessionhub:sess-b' },
+      { s: 'e:b2', t: 'sessionhub:sess-b' },
+      { s: 'sessionhub:sess-a', t: 'root:dsh' },
+      { s: 'sessionhub:sess-b', t: 'root:dsh' },
+    ],
+    lessons: null,
+    retros: [],
+    recent: [],
+  }
+  renderer.setData(islandPayload)
+  for (let f = 0; f < 150; f += 1) {
+    tick += 16.7
+    if (typeof windowStub.__raf === 'function') {
+      const frame = windowStub.__raf
+      windowStub.__raf = null
+      frame(tick)
+    }
+  }
+  const at = (id) => {
+    const i = new Map(state.nodes.map((node, k) => [node.id, k])).get(id)
+    return [state.pos[i * 3], state.pos[i * 3 + 1], state.pos[i * 3 + 2]]
+  }
+  const near = (p, q) => Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2])
+  const hubA = at('sessionhub:sess-a')
+  const hubB = at('sessionhub:sess-b')
+  const ownA = Math.max(near(at('e:a1'), hubA), near(at('e:a2'), hubA))
+  const crossA = Math.min(near(at('e:a1'), hubB), near(at('e:a2'), hubB))
+  const ownB = Math.max(near(at('e:b1'), hubB), near(at('e:b2'), hubB))
+  const crossB = Math.min(near(at('e:b1'), hubA), near(at('e:b2'), hubA))
+  check('window a holds its own failures', ownA < crossA, ownA.toFixed(1) + ' vs ' + crossA.toFixed(1))
+  check('window b holds its own failures', ownB < crossB, ownB.toFixed(1) + ' vs ' + crossB.toFixed(1))
+  check('the windows sit on different islands', near(hubA, hubB) > 8, near(hubA, hubB).toFixed(1))
+
   renderer.dispose()
 
   // The dictionary follows the DSH language setting: re-apply with an English locale and
@@ -638,7 +754,7 @@ async function lessonSection() {
       retros: [
         {
           id: 'r1',
-          at: now - hour,
+          at: now - 60 * 60 * 1000,
           auto: false,
           title: 'fix boom',
           done: 'edited src/x.ts',
@@ -707,6 +823,107 @@ async function lessonSection() {
 }
 
 
+// ── impact ─────────────────────────────────────────────────────────────────
+// The number the plugin exists for: of the lessons that can be judged at all, how many
+// had their signatures come back anyway.
+async function impactSection() {
+  section('impact')
+  const home = tempHome('impact')
+  const now = Date.now()
+  const hour = 60 * 60 * 1000
+  const retro = (id, at, errorIds, extra) =>
+    Object.assign(
+      {
+        id,
+        at,
+        auto: false,
+        title: 'task ' + id,
+        done: 'changed',
+        cause: 'c',
+        fix: 'f',
+        lesson: 'lesson ' + id,
+        tags: ['edit'],
+        tools: ['edit'],
+        files: ['C:/work/proj-a/src/a.ts'],
+        cwd: 'C:/work',
+        errors: [],
+        errorIds,
+      },
+      extra || {},
+    )
+  writeFileSync(
+    join(home, 'error-atlas', 'records.json'),
+    JSON.stringify({
+      version: 2,
+      updatedAt: now,
+      records: [
+        {
+          key: 'tool\u0000edit\u0000boom',
+          id: 'e1',
+          kind: 'tool',
+          name: 'edit',
+          message: 'boom',
+          count: 2,
+          first: now - 5 * hour,
+          last: now - 10 * 60 * 1000,
+          sessions: ['s'],
+        },
+        {
+          key: 'tool\u0000pwsh\u0000sunless',
+          id: 'e2',
+          kind: 'tool',
+          name: 'pwsh',
+          message: 'no lesson here',
+          count: 1,
+          first: now - 4 * hour,
+          last: now - 4 * hour,
+          sessions: ['s'],
+        },
+      ],
+      log: [
+        { at: now - 10 * 60 * 1000, kind: 'tool', name: 'edit', message: 'boom', sessionId: 's' },
+        { at: now - 4 * hour, kind: 'tool', name: 'pwsh', message: 'no lesson here', sessionId: 's' },
+        { at: now - 40 * 24 * hour, kind: 'tool', name: 'edit', message: 'ancient', sessionId: 's' },
+      ],
+      retros: [
+        retro('r1', now - 3 * hour, ['e1']),
+        retro('r2', now - 2 * hour, []),
+        retro('r3', now - hour, [], { auto: true }),
+      ],
+    }),
+  )
+
+  const host = await bootHost(home)
+  const tool = host.tools.find((item) => item.name === 'atlas_impact')
+  check('the impact tool is registered', Boolean(tool))
+  if (!tool) return
+
+  const impact = await tool.execute({})
+  eq('every retrospective is counted', impact.lessons, 3)
+  eq('model retrospectives are separated', impact.model, 2)
+  eq('auto skeletons are separated', impact.auto, 1)
+  eq('only lessons that name a live failure are judgeable', impact.judgeable, 1)
+  eq('a lesson whose failure came back counts as failed', impact.failed, 1)
+  eq('nothing was held against the only judged lesson', impact.held, 0)
+  eq('the failure rate is a percentage', impact.rate, 100)
+  eq('the store size is reported', impact.distinct, 2)
+  eq('coverage counts signatures with a lesson', impact.withLesson, 1)
+  eq('coverage is a percentage', impact.coverage, 50)
+  eq('the failure log is counted', impact.hits, 3)
+  eq('the window keeps the old failure out', impact.hitsInWindow, 2)
+  check('failures after the first lesson are counted', impact.afterFirstLesson >= 1, String(impact.afterFirstLesson))
+  eq('the default window is 30 days', impact.days, 30)
+  eq('a shorter window is honoured', (await tool.execute({ days: 1 })).days, 1)
+  eq('a silly window is clamped', (await tool.execute({ days: 9999 })).days, 365)
+
+  const text = tool.output.render({}, impact)[0].text
+  check('the rendered impact reads like a report', text.includes('judged lessons recurred'), text.slice(0, 120))
+  check('the rendered impact reports coverage', text.includes('carry a lesson'))
+
+  const payload = (await host.call('/error-atlas/data')).json
+  eq('the panel payload carries the same numbers', payload.impact ? payload.impact.judgeable : -1, 1)
+}
+
 // ── board ──────────────────────────────────────────────────────────────────
 // The effectiveness leaderboard: a lesson library is only useful if the reader can see
 // which kinds of lesson keep failing without opening every entry.
@@ -808,8 +1025,117 @@ async function manifestSection() {
   check('the client carries a build stamp', /const BUILD = 'V\d+'/.test(client))
 }
 
+// ── caps ───────────────────────────────────────────────────────────────────
+async function capSection() {
+  section('caps')
+  const home = tempHome('caps')
+  const host = await bootHost(home, { maxNodes: 3 })
+  const agent = { id: 'sess-caps' }
+  for (let i = 0; i < 12; i += 1) toolFailure(host, agent, 'edit', 'C:/work/proj/f' + i + '.js', 'failure ' + i)
+  const small = await host.call('/error-atlas/data')
+  eq('a low cap truncates', small.json.stats.truncated, 9)
+  eq('a low cap keeps the requested nodes', small.json.nodes.filter((node) => node.kind === 'tool' || node.kind === 'exit').length, 3)
+
+  // The default cap has to hold a real atlas: 260 failures used to be cut off at 240.
+  const bigHome = tempHome('caps-big')
+  const big = await bootHost(bigHome)
+  const bigAgent = { id: 'sess-big' }
+  for (let i = 0; i < 260; i += 1) toolFailure(big, bigAgent, 'edit', 'C:/work/proj/f' + i + '.js', 'failure ' + i)
+  const full = await big.call('/error-atlas/data')
+  eq('the default cap holds 260 failures', full.json.nodes.filter((node) => node.kind === 'tool' || node.kind === 'exit').length, 260)
+  eq('the default cap hides nothing', full.json.stats.truncated, 0)
+}
+
+async function noiseSection() {
+  section('noise')
+  const home = tempHome('noise')
+  const host = await bootHost(home)
+  const agent = { id: 'sess-noise' }
+
+  // Two different command lines that both run the same script: one signature, not two.
+  host.fire('tools/result', { name: 'pwsh', arguments: { command: 'cd D:/work; & "C:/Program Files/nodejs/node.exe" build.mjs' }, agent }, {
+    isError: false,
+    content: [{ type: 'text', text: 'boom\n[exit code: 1]' }],
+  })
+  host.fire('tools/result', { name: 'pwsh', arguments: { command: 'cd D:/other; node build.mjs' }, agent }, {
+    isError: false,
+    content: [{ type: 'text', text: 'boom\n[exit code: 1]' }],
+  })
+  const first = await host.call('/error-atlas/data')
+  const exits = first.json.nodes.filter((node) => node.kind === 'exit')
+  eq('the shell fingerprint collapses command variants', exits.length, 1)
+  check('the fingerprint names the script', /node build\.mjs/.test(exits[0].message), exits[0].message)
+  check('stderr rides along as the detail', /boom/.test(exits[0].message), exits[0].message)
+  eq('a described exit is not bare noise', first.json.stats.noise, 0)
+
+  // Five identical bare exits (no stderr) are churn: hidden, counted, and swtichable.
+  for (let i = 0; i < 6; i += 1) {
+    host.fire('tools/result', { name: 'pwsh', arguments: { command: 'cd D:/work; node silent.mjs' }, agent }, {
+      isError: false,
+      content: [{ type: 'text', text: '[exit code: 1]' }],
+    })
+  }
+  const hidden = await host.call('/error-atlas/data')
+  eq('bare repeats leave the graph', hidden.json.nodes.filter((node) => /silent\.mjs/.test(node.message)).length, 0)
+  check('and they are counted instead', hidden.json.stats.noise >= 1, 'noise=' + hidden.json.stats.noise)
+
+  const shown = await host.call('/error-atlas/prefs', 'POST', { showNoise: true })
+  eq('the switch is stored', shown.json.prefs.showNoise, true)
+  const revealed = await host.call('/error-atlas/data')
+  eq('asking for noise brings it back', revealed.json.nodes.filter((node) => /silent\.mjs/.test(node.message)).length, 1)
+
+  // Essence is what gets injected, and a retro that arrived without one gets one derived.
+  const withEssence = host.tools.find((tool) => tool.name === 'atlas_retro')
+  await withEssence.execute({
+    title: 'essence test',
+    lesson: 'An essay-length lesson that should never reach the prompt verbatim because it is far too long to be useful in context.',
+    essence: 'if a shell command fails twice -> command churn -> change the command, not the shell',
+  }, { agent })
+  await host.call('/error-atlas/retro', 'POST', {
+    title: 'derived essence',
+    lesson: '数据可视化里标签和相机距离是两个自由度',
+  })
+  const brief = host.contexts.find((entry) => entry.name === 'error-atlas:lessons')
+  const text = brief.text({})
+  check('the briefing uses the essence', /change the command, not the shell/.test(text), text.slice(0, 200))
+  check('and not the essay', !/essay-length lesson/.test(text), 'leaked the essay')
+  check('a missing essence is derived as a rule', /规则：/.test(text), text.slice(0, 300))
+  check('the briefing stays under three lessons', (text.match(/^- /gm) || []).length <= 3, text)
+
+  // Ambient churn must not invalidate every lesson that ran beside it: a signature many
+  // lessons point at is the environment, not the mistake any one of them was about.
+  const ambientHome = tempHome('ambient')
+  const now = Date.now()
+  writeFileSync(
+    join(ambientHome, 'error-atlas', 'records.json'),
+    JSON.stringify({
+      version: 3,
+      updatedAt: now,
+      records: [
+        { key: 'k1', id: 'e1', kind: 'pwsh', name: 'git', message: 'git -c', count: 40, first: now - 3 * 60 * 60 * 1000, last: now + 30 * 1000, sessions: ['s'], turn: 1, step: 1 },
+      ],
+      log: [{ at: now + 30 * 1000, kind: 'pwsh', name: 'git', message: 'git -c', sessionId: 's' }],
+      retros: Array.from({ length: 5 }, (_, index) => ({
+        id: 'r' + (index + 1),
+        at: now - 60 * 60 * 1000,
+        auto: false,
+        title: 'lesson ' + (index + 1),
+        lesson: 'do the thing differently',
+        errorIds: ['e1'],
+        tags: ['git'],
+        tools: ['pwsh'],
+        files: [],
+      })),
+    }),
+  )
+  const ambientHost = await bootHost(ambientHome)
+  const ambientTool = ambientHost.tools.find((item) => item.name === 'atlas_lessons')
+  const ambientLessons = await ambientTool.execute({})
+  eq('an ambient signature does not mark lessons stale', ambientLessons.lessons.filter((item) => item.stale > 0).length, 0)
+}
+
 // ── run ────────────────────────────────────────────────────────────────────
-const sections = [storeSection, retroSection, prefsSection, trendSection, projectSection, exportSection, lessonSection, boardSection, clientSection, manifestSection]
+const sections = [storeSection, retroSection, prefsSection, trendSection, projectSection, exportSection, lessonSection, noiseSection, impactSection, boardSection, clientSection, capSection, manifestSection]
 for (const run of sections) {
   try {
     await run()