@1aboveio/skills 1.0.7 → 1.0.9

package/skills/engineering/resolve-issues/scripts/ready-check.test.mjs

@@ -1,217 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { chmodSync, mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { DEFAULT_LABEL, ReadyCheckError, parseArgs, parseIssueRef, readyCheck, treeFetchers } from './ready-check.mjs'
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'ready-check.mjs')
-
-// A small in-memory GitHub: issues keyed "owner/name#n", sub-issues as API-shaped children.
-function fakeGithub(issues, subIssues = {}) {
-  return {
-    fetchIssue: ({ repo, number }) => {
-      const issue = issues[`${repo}#${number}`]
-      if (!issue) throw new Error(`HTTP 404 ${repo}#${number}`)
-      return issue
-    },
-    fetchSubIssues: ({ repo, number }) => (subIssues[`${repo}#${number}`] || []).map((ref) => {
-      const [childRepo, n] = ref.split('#')
-      return { number: Number(n), repository_url: `https://api.github.com/repos/${childRepo}` }
-    }),
-  }
-}
-const issue = (labels, state = 'open', title = 't') => ({ state, title, labels: labels.map((name) => ({ name })) })
-
-test('the default label is ready-for-agent', () => {
-  assert.equal(DEFAULT_LABEL, 'ready-for-agent')
-})
-
-test('an issue and all its sub-issues labeled ready passes', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['epic', 'ready-for-agent']), 'o/r#2': issue(['ready-for-agent']), 'o/r#3': issue(['Ready-For-Agent']) },
-    { 'o/r#1': ['o/r#2', 'o/r#3'] },
-  )
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, true)
-  assert.equal(result.checked.length, 3, 'label match ignores case')
-})
-
-test('an epic without the label passes when all its open sub-issues are ready', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['epic']), 'o/r#2': issue(['ready-for-agent']), 'o/r#3': issue(['epic']), 'o/r#4': issue(['ready-for-agent']) },
-    { 'o/r#1': ['o/r#2', 'o/r#3'], 'o/r#3': ['o/r#4'] },
-  )
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, true)
-  assert.deepEqual(result.checked.filter((c) => c.exempt).map((c) => c.ref), ['o/r#1', 'o/r#3'], 'nested epics are exempt too')
-})
-
-test('an epic without the label still reports a sub-issue that is not ready', () => {
-  const gh = fakeGithub({ 'o/r#1': issue(['epic']), 'o/r#2': issue(['triage']) }, { 'o/r#1': ['o/r#2'] })
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, false)
-  assert.deepEqual(result.missing.map((m) => m.ref), ['o/r#2'])
-})
-
-test('an open issue whose sub-issues are all closed is a unit again: a rollup that needs the label', () => {
-  // #1343 was held, its prerequisite #1659 was filed under it and closed: the old check
-  // called #1343 resolved and the run dropped its remaining work.
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['epic']), 'o/r#2': issue([], 'closed'), 'o/r#3': issue(['ready-for-agent']), 'o/r#4': issue([], 'closed') },
-    { 'o/r#1': ['o/r#2'], 'o/r#3': ['o/r#4'] },
-  )
-  const result = readyCheck([{ repo: 'o/r', number: 1 }, { repo: 'o/r', number: 3 }], gh)
-  assert.equal(result.ready, false)
-  assert.deepEqual(result.missing.map((m) => m.ref), ['o/r#1'])
-  assert.deepEqual(result.rollups.map((r) => r.ref), ['o/r#1', 'o/r#3'])
-})
-
-test('an epic whose only open sub-issue is a rollup stays a container', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['epic']), 'o/r#2': issue(['ready-for-agent']), 'o/r#3': issue([], 'closed') },
-    { 'o/r#1': ['o/r#2'], 'o/r#2': ['o/r#3'] },
-  )
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, true)
-  assert.equal(result.checked.find((c) => c.ref === 'o/r#1').exempt, 'has open sub-issues')
-  assert.deepEqual(result.rollups.map((r) => r.ref), ['o/r#2'])
-})
-
-test('a plain issue with no sub-issues is a unit, not a rollup', () => {
-  const gh = fakeGithub({ 'o/r#1': issue([]) })
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, false)
-  assert.deepEqual(result.rollups, [])
-})
-
-test('an epic with an unreadable sub-issue is neither exempt nor a rollup', () => {
-  const gh = fakeGithub({ 'o/r#1': issue(['epic']) }, { 'o/r#1': ['o/r#404'] })
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, false)
-  assert.deepEqual(result.missing.map((m) => m.ref), ['o/r#1'])
-  assert.deepEqual(result.unreadable.map((m) => m.ref), ['o/r#404'])
-  const partly = fakeGithub({ 'o/r#1': issue(['epic']), 'o/r#2': issue([], 'closed') }, { 'o/r#1': ['o/r#2', 'o/r#404'] })
-  assert.deepEqual(readyCheck([{ repo: 'o/r', number: 1 }], partly).rollups, [], 'one closed plus one unreadable is not a rollup')
-})
-
-test('tree fetchers answer from the GraphQL tree and fall back to REST for the rest', () => {
-  const tree = { nodes: {
-    'o/r#1': { key: 'o/r#1', state: 'open', title: 'epic', labels: ['epic'], children: ['o/r#2', 'x/y#9'] },
-    'o/r#2': { key: 'o/r#2', state: 'open', title: 'a', labels: ['ready-for-agent'], children: [] },
-    'x/y#9': { key: 'x/y#9', state: 'open', title: 'deep', labels: ['ready-for-agent'], children: null },
-  } }
-  const calls = []
-  const rest = fakeGithub({ 'x/y#10': issue(['ready-for-agent']) }, { 'x/y#9': ['x/y#10'] })
-  const fallback = { fetchIssue: (r) => { calls.push(`issue ${r.repo}#${r.number}`); return rest.fetchIssue(r) }, fetchSubIssues: (r) => { calls.push(`subs ${r.repo}#${r.number}`); return rest.fetchSubIssues(r) } }
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], treeFetchers([tree], fallback))
-  assert.equal(result.ready, true)
-  assert.deepEqual(calls, ['subs x/y#9', 'issue x/y#10', 'subs x/y#10'], 'only the part the tree did not cover hits REST')
-})
-
-test('a sub-issue shared by two epics makes both containers', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['epic']), 'o/r#2': issue(['epic']), 'o/r#3': issue(['ready-for-agent']) },
-    { 'o/r#1': ['o/r#3'], 'o/r#2': ['o/r#3'] },
-  )
-  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }, { repo: 'o/r', number: 2 }], gh).ready, true)
-})
-
-test('a sub-issue at any depth, in another repository, without the label is reported', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['ready-for-agent']), 'o/r#2': issue(['ready-for-agent']), 'x/y#9': issue(['bug']) },
-    { 'o/r#1': ['o/r#2'], 'o/r#2': ['x/y#9'] },
-  )
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, false)
-  assert.deepEqual(result.missing, [{ ref: 'x/y#9', title: 't', labels: ['bug'], parent: 'o/r#2' }])
-  assert.equal(result.checked.find((c) => c.ref === 'x/y#9').depth, 2)
-})
-
-test('closed sub-issues are skipped; a closed named issue is still checked', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['ready-for-agent']), 'o/r#2': issue([], 'closed'), 'o/r#5': issue([], 'closed') },
-    { 'o/r#1': ['o/r#2'] },
-  )
-  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], gh).ready, true)
-  assert.equal(readyCheck([{ repo: 'o/r', number: 5 }], gh).ready, false)
-})
-
-test('an unreadable issue or sub-issue list fails closed', () => {
-  const gh = fakeGithub({ 'o/r#1': issue(['ready-for-agent']) }, { 'o/r#1': ['o/r#404'] })
-  const result = readyCheck([{ repo: 'o/r', number: 1 }], gh)
-  assert.equal(result.ready, false)
-  assert.equal(result.unreadable[0].ref, 'o/r#404')
-  const brokenList = { ...gh, fetchSubIssues: () => { throw new Error('HTTP 502') } }
-  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], brokenList).ready, false)
-})
-
-test('a sub-issue loop is walked once', () => {
-  const gh = fakeGithub(
-    { 'o/r#1': issue(['ready-for-agent']), 'o/r#2': issue(['ready-for-agent']) },
-    { 'o/r#1': ['o/r#2'], 'o/r#2': ['o/r#1'] },
-  )
-  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], gh).checked.length, 2)
-})
-
-test('a custom label is honored', () => {
-  const gh = fakeGithub({ 'o/r#1': issue(['agent-ok']) })
-  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], { ...gh, label: 'agent-ok' }).ready, true)
-  assert.equal(readyCheck([{ repo: 'o/r', number: 1 }], gh).ready, false)
-})
-
-test('issue references accept owner/name#n, URLs, and bare numbers with a repo', () => {
-  assert.deepEqual(parseIssueRef('o/r#12'), { repo: 'o/r', number: 12 })
-  assert.deepEqual(parseIssueRef('https://github.com/o/r/issues/7'), { repo: 'o/r', number: 7 })
-  assert.deepEqual(parseIssueRef('#3', 'o/r'), { repo: 'o/r', number: 3 })
-  assert.throws(() => parseIssueRef('3'), ReadyCheckError)
-  assert.throws(() => parseArgs([]), ReadyCheckError)
-  assert.throws(() => parseArgs(['--bogus']), ReadyCheckError)
-})
-
-// ---- CLI against a fake `gh` on PATH ----
-
-function withFakeGh(responses) {
-  const dir = mkdtempSync(join(tmpdir(), 'ready-check-gh-'))
-  const cases = Object.entries(responses)
-    .map(([path, body]) => `  "${path}") cat <<'EOF'\n${JSON.stringify(body)}\nEOF\n  ;;`)
-    .join('\n')
-  // gh api [--paginate --slurp] <path>: the path is the last argument.
-  writeFileSync(join(dir, 'gh'), `#!/bin/sh\nfor last; do :; done\ncase "$last" in\n${cases}\n  *) echo "HTTP 404" >&2; exit 1 ;;\nesac\n`)
-  chmodSync(join(dir, 'gh'), 0o755)
-  return { ...process.env, PATH: `${dir}:${process.env.PATH}` }
-}
-
-test('CLI exits 0 with the outcome in the output, 2 on bad input; --exit-outcome restores the old codes', () => {
-  const env = withFakeGh({
-    'repos/o/r/issues/1': issue(['ready-for-agent']),
-    'repos/o/r/issues/1/sub_issues': [[{ number: 2, repository_url: 'https://api.github.com/repos/o/r' }]],
-    'repos/o/r/issues/2': issue(['triage'], 'open', 'Add login'),
-    'repos/o/r/issues/2/sub_issues': [[]],
-    'repos/o/r/issues/3': issue(['ready-for-agent']),
-    'repos/o/r/issues/3/sub_issues': [[]],
-  })
-  const ok = spawnSync(process.execPath, [script, '--issue', 'o/r#3'], { env, encoding: 'utf8' })
-  assert.equal(ok.status, 0, ok.stderr)
-  assert.equal(JSON.parse(ok.stdout).outcome, 'ready')
-  const unlabeled = spawnSync(process.execPath, [script, '--repo', 'o/r', '--issue', '1'], { env, encoding: 'utf8' })
-  assert.equal(unlabeled.status, 0, unlabeled.stderr)
-  assert.equal(JSON.parse(unlabeled.stdout).outcome, 'unlabeled')
-  assert.deepEqual(JSON.parse(unlabeled.stdout).missing, [{ ref: 'o/r#2', title: 'Add login', labels: ['triage'], parent: 'o/r#1' }])
-  const named = spawnSync(process.execPath, [script, '--issue', 'o/r#2'], { env, encoding: 'utf8' })
-  assert.equal(named.status, 0, named.stderr)
-  assert.equal(JSON.parse(named.stdout).missing[0].parent, null)
-  const unreadable = spawnSync(process.execPath, [script, '--issue', 'o/r#2', '--issue', 'o/r#404'], { env, encoding: 'utf8' })
-  assert.equal(unreadable.status, 0, unreadable.stderr)
-  assert.equal(JSON.parse(unreadable.stdout).outcome, 'unreadable', 'an unreadable issue outranks an unlabeled one')
-  const legacy = (...args) => spawnSync(process.execPath, [script, '--exit-outcome', ...args], { env, encoding: 'utf8' }).status
-  assert.equal(legacy('--issue', 'o/r#3'), 0)
-  assert.equal(legacy('--repo', 'o/r', '--issue', '1'), 3)
-  assert.equal(legacy('--issue', 'o/r#2', '--issue', 'o/r#404'), 1)
-  assert.equal(legacy(), 2)
-  const usage = spawnSync(process.execPath, [script], { env, encoding: 'utf8' })
-  assert.equal(usage.status, 2)
-})

package/skills/engineering/resolve-issues/scripts/rehydrate.test.mjs

@@ -1,91 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { activeRuns, message, ACTIVE_HOURS } from './rehydrate.mjs'
-import { RULES, SKILL_PATH } from './next-actions.mjs'
-
-const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'rehydrate.mjs')
-
-function repo(runs) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'rehydrate-'))
-  for (const [name, plan, ageHours = 0] of runs) {
-    const dir = path.join(cwd, '.resolve-issues', 'rush', name)
-    fs.mkdirSync(dir, { recursive: true })
-    const file = path.join(dir, 'task-plan.json')
-    fs.writeFileSync(file, typeof plan === 'string' ? plan : JSON.stringify(plan))
-    const at = new Date(Date.now() - ageHours * 3_600_000)
-    fs.utimesSync(file, at, at)
-  }
-  return cwd
-}
-
-test('only a recent run with an open unit counts; finished, stale, and unreadable runs do not', () => {
-  const cwd = repo([
-    ['live', { skill: 'rush-issues', planRevision: 267, units: [{ id: '1', status: 'succeeded' }, { id: '2', status: 'in-flight' }, { id: '3', status: 'blocked' }] }, 1],
-    ['done', { units: [{ id: '1', status: 'succeeded' }, { id: '2', status: 'cancelled' }] }],
-    ['stale', { units: [{ id: '1', status: 'in-flight' }] }, ACTIVE_HOURS + 1],
-    ['broken', '{not json'],
-  ])
-  const runs = activeRuns(cwd)
-  assert.deepEqual(runs, [{ dir: path.join(cwd, '.resolve-issues', 'rush', 'live'), skill: 'rush-issues', revision: 267, open: 2 }])
-  assert.deepEqual(activeRuns(fs.mkdtempSync(path.join(os.tmpdir(), 'rehydrate-none-'))), [], 'no .resolve-issues: nothing')
-  const unit = path.join(cwd, '.resolve-issues', 'rush', 'live', 'units', '7')
-  fs.mkdirSync(unit, { recursive: true })
-  assert.deepEqual(activeRuns(unit), runs, 'a coordinator standing in a unit workspace still finds its run')
-})
-
-test('the message names both skills for a rush run, each run with its next-actions command, and the rules', () => {
-  const dir = '/repo/.resolve-issues/rush/r1'
-  const rush = path.join(path.dirname(path.dirname(SKILL_PATH)), 'rush-issues', 'SKILL.md')
-  const text = message([{ dir, skill: 'rush-issues', revision: 5, open: 3 }], { rushSkillPath: SKILL_PATH })
-  assert.match(text, /read each of these in full, with no line limit/)
-  assert.ok(text.includes(`- ${SKILL_PATH}\n`))
-  assert.ok(text.includes(`next-actions.mjs --run ${dir} --capacity-json '<fresh snapshot JSON>'`))
-  assert.match(text, /Read subagent_settings now/)
-  assert.match(text, /no default worker count/)
-  assert.ok(text.endsWith(RULES))
-  const plain = message([{ dir, skill: 'resolve-issues', revision: 5, open: 3 }], { rushSkillPath: rush })
-  assert.ok(!plain.includes('rush-issues/SKILL.md'), 'a resolve-issues run reads only its own skill')
-  assert.equal(message([]), '')
-})
-
-test('each recovered run refreshes capacity separately instead of reusing one snapshot', () => {
-  const text = message([
-    { dir: '/repo/.resolve-issues/rush/first', skill: 'resolve-issues', revision: 1, open: 6 },
-    { dir: '/repo/.resolve-issues/rush/second', skill: 'resolve-issues', revision: 2, open: 3 },
-  ])
-  const commands = text.split('\n').filter(line => line.includes('next-actions.mjs --run'))
-  assert.equal(commands.length, 2)
-  for (const command of commands) {
-    assert.match(command, /refresh subagent_settings immediately before node/)
-    assert.match(command, /--capacity-json '<fresh snapshot JSON>'/)
-  }
-})
-
-test('as a hook it reads cwd from stdin, prints SessionStart context, and prints nothing without a run', () => {
-  const cwd = repo([['live', { skill: 'resolve-issues', units: [{ id: '1', status: 'pending' }] }]])
-  const run = (input) => spawnSync(process.execPath, [SCRIPT, '--hook'], { input, encoding: 'utf8', cwd: os.tmpdir() })
-  const out = run(JSON.stringify({ hook_event_name: 'SessionStart', source: 'compact', cwd }))
-  assert.equal(out.status, 0)
-  const parsed = JSON.parse(out.stdout)
-  assert.equal(parsed.hookSpecificOutput.hookEventName, 'SessionStart')
-  assert.match(parsed.hookSpecificOutput.additionalContext, /Runs in progress here:/)
-  const empty = run(JSON.stringify({ cwd: fs.mkdtempSync(path.join(os.tmpdir(), 'rehydrate-empty-')) }))
-  assert.equal(empty.status, 0)
-  assert.equal(empty.stdout, '')
-  assert.equal(run('not json').status, 0, 'bad input never blocks a session')
-})
-
-test('rush-issues/rehydrate.mjs prints the same message, for a harness that runs the owner skill\'s script', () => {
-  const cwd = repo([['live', { skill: 'rush-issues', units: [{ id: '1', status: 'in-flight' }] }]])
-  const rush = path.join(path.dirname(path.dirname(SKILL_PATH)), 'rush-issues', 'rehydrate.mjs')
-  const out = spawnSync(process.execPath, [rush, '--cwd', cwd], { encoding: 'utf8' })
-  assert.equal(out.status, 0)
-  assert.equal(out.stdout, `${message(activeRuns(cwd))}\n`)
-  assert.match(out.stdout, /rush-issues\/SKILL\.md/)
-})