kaloko 0.5.0 → 0.5.2

package/src/lib/stability.mjs

@@ -227,6 +227,88 @@ export async function applySuggestions (file, report) {
   return { applied, skipped }
 }
 
+const sameEntry = (a, b) => JSON.stringify({ rect: a.rect, viewport: a.viewport, selector: a.selector }) === JSON.stringify({ rect: b.rect, viewport: b.viewport, selector: b.selector })
+
+/**
+ * Adds ignore entries to steps of the scenario file, appending to an existing block-style `ignore:` list or creating
+ * one (comments and formatting stay; flow-style lists are left alone). `byNode`: Map node → entries.
+ * Returns { applied: [{ node, entries }], skipped: [reason] }; entries already in the file are not added twice.
+ */
+export async function mergeIgnore (file, byNode) {
+  let text = await readFile(file, 'utf8')
+  const applied = []; const skipped = []
+  for (const [nodeId, entries] of byNode) {
+    const parsed = yaml.load(text)
+    const node = (parsed?.nodes || []).find((n) => n.id === nodeId)
+    if (!node) { skipped.push(`${nodeId}: not in ${file}`); continue }
+    const fresh = entries.filter((e) => !(Array.isArray(node.ignore) ? node.ignore : []).some((x) => sameEntry(x, e)))
+    if (!fresh.length) { applied.push({ node: nodeId, entries: [] }); continue }
+    const lines = text.split('\n')
+    const at = lines.findIndex((l) => new RegExp(`^(\\s*)- id: ['"]?${nodeId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]?\\s*(#.*)?$`).test(l))
+    if (at < 0) { skipped.push(`${nodeId}: node is not in block style; add the regions by hand`); continue }
+    const dash = lines[at].match(/^(\s*)-/)[1].length
+    const indent = ' '.repeat(dash + 2)
+    // the node's block: lines indented deeper than its dash (blank lines included)
+    let end = at + 1
+    while (end < lines.length && (!lines[end].trim() || lines[end].match(/^(\s*)/)[1].length > dash)) end++
+    while (end > at + 1 && !lines[end - 1].trim()) end--
+    const key = lines.slice(at + 1, end).findIndex((l) => l.startsWith(`${indent}ignore:`))
+    const item = (e, pad) => `${pad}- ${yaml.dump(e, { flowLevel: 0, lineWidth: 400 }).trim()}`
+    let block
+    if (key < 0) {
+      block = { at: end, lines: [`${indent}ignore:`, ...fresh.map((e) => item(e, indent + '  '))] }
+    } else {
+      const k = at + 1 + key
+      if (lines[k].replace(/#.*$/, '').trim() !== 'ignore:') { skipped.push(`${nodeId}: ignore is written inline; add the regions by hand`); continue }
+      // list items follow at the key's indentation or deeper; the list ends at the next line that is neither
+      let j = k + 1; let pad = null
+      while (j < end) {
+        const l = lines[j]
+        if (!l.trim()) { j++; continue }
+        const ind = l.match(/^(\s*)/)[1].length
+        if (pad == null) { if (!l.trimStart().startsWith('- ') || ind < indent.length) break; pad = ' '.repeat(ind) }
+        if (ind < pad.length || (ind === pad.length && !l.trimStart().startsWith('- '))) break
+        j++
+      }
+      while (j > k + 1 && !lines[j - 1].trim()) j--
+      block = { at: j, lines: fresh.map((e) => item(e, pad ?? indent + '  ')) }
+    }
+    const next = [...lines.slice(0, block.at), ...block.lines, ...lines.slice(block.at)].join('\n')
+    let ok = false
+    try { const n2 = (yaml.load(next)?.nodes || []).find((n) => n.id === nodeId); ok = Array.isArray(n2?.ignore) && n2.ignore.length === (Array.isArray(node.ignore) ? node.ignore.length : 0) + fresh.length } catch {}
+    if (!ok) { skipped.push(`${nodeId}: could not add to its ignore list safely; add the regions by hand`); continue }
+    text = next
+    applied.push({ node: nodeId, entries: fresh })
+  }
+  if (applied.some((a) => a.entries.length)) await writeFile(file, text)
+  return { applied, skipped }
+}
+
+/**
+ * `kaloko stability --pull`: regions people drew on the canvas (Developer / Tester and up) become ignore: entries of
+ * their steps in the scenario file; the service then stops showing them as suggestions.
+ */
+export async function pullDrawn ({ root, config, run, args, say, client }) {
+  const scenarioId = typeof args.scenario === 'string' ? args.scenario : run.meta.scenario.id
+  const data = await client.request('GET', `/orgs/${config.org}/scenarios/${encodeURIComponent(scenarioId)}/ignore-regions`)
+  const regions = data.regions || []
+  if (!regions.length) { say(`No drawn regions wait for ${scenarioId}. Draw them on a screenshot on kaloko.app (step detail → Page → Draw a region).`); return { applied: [], skipped: [], regions: [] } }
+  const byNode = new Map()
+  for (const r of regions) (byNode.get(r.node_id) || byNode.set(r.node_id, []).get(r.node_id)).push(r.scenario_entry)
+  const file = resolve(root, run.meta.scenario_file)
+  const out = await mergeIgnore(file, byNode)
+  const done = new Set(out.applied.map((a) => a.node))
+  const ids = regions.filter((r) => done.has(r.node_id)).map((r) => r.id)
+  if (ids.length) await client.request('POST', `/orgs/${config.org}/scenarios/${encodeURIComponent(scenarioId)}/ignore-regions/applied`, { ids })
+  if (args.json) { say(JSON.stringify({ ...out, regions }, null, 2)); return out }
+  const added = out.applied.reduce((n, a) => n + a.entries.length, 0)
+  say(`Pulled ${regions.length} drawn region(s) of ${scenarioId}: ${added} added to ${run.meta.scenario_file}${added < ids.length ? `, ${ids.length - added} already there` : ''}.`)
+  for (const a of out.applied.filter((x) => x.entries.length)) say(`  ${a.node}: ${a.entries.map((e) => `[${e.rect.join(', ')}] on ${e.viewport}`).join('; ')}`)
+  for (const x of out.skipped) say(`  skipped ${x}`)
+  if (added) say('Walk those steps again so the canvas and pixel diffs use them.')
+  return out
+}
+
 /** `kaloko stability`: detect, write stability.json and stability.yml in the run, print, optionally apply. */
 export async function stabilityCmd ({ root, config, run, scenario, args, say }) {
   const report = await detectUnstable({ root, config, run, scenario, last: Number(args.last) || 4, runs: typeof args.runs === 'string' ? args.runs.split(',').map((s) => s.trim()).filter(Boolean) : null, sameCommit: !!args['same-commit'] })