tspl-cli 0.0.0-stage → 0.1.1

package/src/task/check.js

@@ -0,0 +1,415 @@
+'use strict'
+
+const Path = require('path').posix
+const { splitTerms, words } = require('../find/text')
+
+const MAX_QUESTIONS = 4
+const BACKEND_LEAD = 3
+const MAX_ASKS = 2
+const BACKEND_ONLY = 'backend only'
+const BUG_WORDS = /\b(bug|error|errors|fail|fails|failing|failed|broken|crash|crashes|wrong|incorrect|not working|doesn'?t work|does not|disappear|disappears|issue|stuck|missing|invalid)\b/i
+const COMMON_VERBS = /^(load|loads|loading|show|shows|showing|open|opens|click|clicks|select|selects|display|displays|work|works|working|keep|keeps|allow|allows|need|needs|should|want|wants|when|where|after|before|still|also|only|every|each|some)$/i
+const FEATURE_WORDS = /\b(add|adding|new|ability|allow|create|support|introduce|enable|implement)\b/i
+const VAGUE = new Set(['add', 'new', 'featur', 'chang', 'updat', 'fix', 'need', 'want', 'make', 'creat', 'issu', 'bug', 'task', 'improv', 'enhanc', 'request', 'ability', 'abl'])
+
+const KIND_LABELS = { app: 'app / screens', api: 'API', shared: 'shared code / jobs' }
+
+const TEMPLATES = {
+  feature: ['what', 'who', 'where', 'how'],
+  change: ['what', 'where', 'now', 'how'],
+  bug: ['what', 'where', 'steps', 'now', 'expected'],
+}
+
+const LABELS = {
+  feature: { what: 'Goal', how: 'How it works' },
+  change: { what: 'What should change', now: 'How it works today', how: 'How it should work' },
+  bug: { what: 'What is broken', now: 'What happens now', expected: 'What should happen' },
+}
+
+const QUESTIONS = {
+  what: {
+    feature: 'What should users be able to do? One or two sentences.',
+    change: 'What should change? One or two sentences.',
+    bug: 'What is broken? One or two sentences.',
+  },
+  who: {
+    header: 'Who',
+    question: 'Who uses it?',
+    multiSelect: true,
+    suggestOptions: 'Suggest 2-4 user roles that fit the chosen app (for example resident, property manager, company admin, support).',
+  },
+  how: {
+    feature: {
+      header: 'How',
+      question: 'How should it work? The steps or rules, for example "a Sync button on the list pulls new work orders from Yardi for that property".',
+      suggestOptions: 'Suggest 2-3 short, different versions of how it could work, based on the task and the code; the user picks one or writes their own.',
+    },
+    change: {
+      header: 'Change',
+      question: 'How should it work after the change?',
+      suggestOptions: 'Suggest 2-3 short versions of the new behaviour; the user picks one or writes their own.',
+    },
+  },
+  now: {
+    change: { header: 'Today', question: 'How does it work today?' },
+  },
+  steps: { header: 'Steps', question: 'What are the steps to make it happen?' },
+  'now, expected': { header: 'Bug', question: 'What happens now, and what should happen instead?' },
+}
+
+const MIN_TERMS = { what: 2, who: 1, how: 4, steps: 3, now: 2, expected: 2 }
+const DESCRIBED = 12
+
+const clean = value => (typeof value === 'string' ? value.trim() : '')
+const list = value => (Array.isArray(value) ? value.map(clean).filter(Boolean) : clean(value) ? [clean(value)] : [])
+
+const typeOf = value => {
+  const type = clean(value).toLowerCase()
+  if (/bug|broken|error|fix/.test(type)) return 'bug'
+  if (/feature|new/.test(type)) return 'feature'
+  if (/change|update|improve/.test(type)) return 'change'
+  return ''
+}
+
+const guessType = text => {
+  if (BUG_WORDS.test(text)) return 'bug'
+  if (FEATURE_WORDS.test(text)) return 'feature'
+  return 'change'
+}
+
+const normalize = card => ({
+  ticket: clean(card.ticket),
+  type: typeOf(card.type),
+  what: clean(card.what),
+  who: clean(card.who),
+  where: clean(card.where),
+  apps: list(card.apps),
+  screen: clean(card.screen),
+  how: clean(card.how),
+  steps: clean(card.steps),
+  now: clean(card.now),
+  expected: clean(card.expected),
+  doneWhen: list(card.doneWhen),
+  details: clean(card.details),
+  skip: Boolean(card.skip),
+  round: Number(card.round) || 0,
+  asked: card.asked && typeof card.asked === 'object' ? { ...card.asked } : {},
+})
+
+const taskText = card =>
+  [card.what, card.who, card.where, card.screen, card.how, card.steps, card.now, card.expected, card.details]
+    .filter(Boolean)
+    .join('. ')
+
+const meaningful = value => splitTerms(value || '').single.filter(term => !VAGUE.has(term)).length
+
+const section = (text, start, stop) => {
+  const match = text.match(new RegExp(`${start}\\s*:?\\s*\\n?([\\s\\S]*?)(?=\\n\\s*(?:${stop})\\b|$)`, 'i'))
+  return match ? match[1].replace(/\s+/g, ' ').trim() : ''
+}
+
+const fromTicket = card => {
+  const text = card.details
+  const found = []
+  if (!text) return found
+  if (!card.who) {
+    const role = text.match(/\bAs an? ([a-z][\w\s/-]{2,40}?)(?:,|\n| I want| who)/i)
+    if (role) {
+      card.who = role[1].trim()
+      found.push('who')
+    }
+  }
+  if (!card.steps) {
+    const steps = section(text, 'steps to reproduce', 'expected|actual')
+    if (steps) {
+      card.steps = steps.slice(0, 400)
+      found.push('steps')
+    }
+  }
+  if (!card.expected) {
+    const expected = text.match(/\bexpected(?: result)?\s*:\s*(.+)/i)
+    if (expected) {
+      card.expected = expected[1].trim().slice(0, 300)
+      found.push('expected')
+    }
+  }
+  if (!card.now) {
+    const actual = text.match(/\bactual(?: result)?\s*:\s*(.+)/i)
+    if (actual) {
+      card.now = actual[1].trim().slice(0, 300)
+      found.push('now')
+    }
+  }
+  if (!card.doneWhen.length) {
+    const scenarios = text
+      .split(/scenario\s*:\s*/i)
+      .slice(1)
+      .map(block => {
+        const [title, ...rest] = block.split('\n')
+        const outcomes = rest.join('\n')
+          .split(/\n|\s+(?=(?:then|and)\s)/i)
+          .map(line => line.trim())
+          .filter(line => /^(then|and)\s/i.test(line))
+          .map(line => line.replace(/^(then|and)\s+/i, ''))
+        const check = outcomes.length ? `${title.trim()}: ${outcomes.join(', ')}` : title.trim()
+        return check.length > 180 ? `${check.slice(0, 180).trim()}…` : check
+      })
+    const thens = [...text.matchAll(/^\s*then\s+([^\n]+)/gim)].map(match => `Then ${match[1].trim()}`)
+    const checks = (scenarios.length ? scenarios : thens).slice(0, 6)
+    if (checks.length) {
+      card.doneWhen = checks
+      found.push('doneWhen')
+    }
+  }
+  return found
+}
+
+const filled = (card, field) => {
+  if (field === 'where') return card.apps.length > 0
+  if (['who', 'how', 'steps', 'now', 'expected'].includes(field) && meaningful(card.details) >= DESCRIBED) return true
+  return meaningful(card[field]) >= (MIN_TERMS[field] || 1)
+}
+
+const humanize = value => {
+  const text = words(value).join(' ')
+  return text.charAt(0).toUpperCase() + text.slice(1)
+}
+
+const isScreenFile = file => {
+  const facts = file.facts
+  return facts.language === 'html' || Boolean(facts.screens) || Boolean(facts.labels) ||
+    (facts.components || []).some(component => component.kind === 'component')
+}
+
+const screenOf = path => {
+  const dir = Path.dirname(path)
+  const base = Path.basename(path).replace(/\.[^.]+$/, '')
+  const stem = base.split('.')[0]
+  return Path.basename(dir) === stem || /\.component$/.test(base) ? dir : Path.join(dir, stem)
+}
+
+const describePlace = (repo, dir) => {
+  const parts = dir.split('/').filter(part => !['src', 'app', 'pages', 'screens', 'components'].includes(part))
+  return [repo, ...parts.slice(0, -1).map(humanize)].join(' › ')
+}
+
+const repoScores = (result, graph) => {
+  const scores = new Map()
+  result.files.forEach(file => scores.set(file.repo, (scores.get(file.repo) || 0) + file.score))
+  const kinds = new Map(graph.repos.map(repo => [repo.name, repo.kind]))
+  return [...scores.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .map(([name, score]) => ({ name, score, kind: kinds.get(name) || 'shared' }))
+}
+
+const APP_KINDS = [
+  ['consol', 'portal', 'web', 'websit', 'site', 'dashboard', 'panel', 'frontend', 'ui', 'client'],
+  ['nativ', 'mobil', 'app', 'ios', 'android', 'phon'],
+  ['api', 'backend', 'server', 'servic'],
+]
+const kindOf = term => APP_KINDS.findIndex(group => group.includes(term))
+
+const namedApps = (card, graph) => {
+  const said = new Set(splitTerms([card.what, card.where].join(' ')).single)
+  const saidKinds = new Set([...said].map(kindOf).filter(kind => kind >= 0))
+  return graph.repos
+    .filter(repo => {
+      const parts = splitTerms(repo.name).single
+      const specific = parts.filter(part => kindOf(part) < 0)
+      const kinds = new Set(parts.map(kindOf).filter(kind => kind >= 0))
+      if (!specific.length || !specific.every(part => said.has(part))) return false
+      return !kinds.size || [...kinds].some(kind => saidKinds.has(kind))
+    })
+    .map(repo => repo.name)
+}
+
+const screenCandidates = (result, graph, apps) => {
+  const appRepos = new Set(graph.repos.filter(repo => repo.kind === 'app' && apps.includes(repo.name)).map(repo => repo.name))
+  const groups = new Map()
+  result.files.forEach(item => {
+    const file = graph.files[item.id]
+    if (!appRepos.has(file.repo) || !isScreenFile(file)) return
+    const dir = screenOf(file.path)
+    const key = `${file.repo}\0${dir}`
+    const group = groups.get(key) || { repo: file.repo, dir, score: 0 }
+    group.score = Math.max(group.score, item.score)
+    groups.set(key, group)
+  })
+  return [...groups.values()]
+    .sort((a, b) => b.score - a.score)
+    .map(group => ({
+      label: humanize(Path.basename(group.dir)),
+      value: `${group.repo}/${group.dir}`,
+      description: describePlace(group.repo, group.dir),
+      score: group.score,
+    }))
+}
+
+const shorten = (value, length) => (value.length > length ? `${value.slice(0, length).trim()}…` : value)
+
+const summaryOf = (card, assumptions) => {
+  const labels = LABELS[card.type] || {}
+  const line = (field, fallback) => (card[field] ? `${labels[field] || fallback}: ${card[field]}` : null)
+  return [
+    card.ticket ? `Ticket: ${card.ticket}` : null,
+    `Type: ${card.type}`,
+    line('what', 'Task'),
+    line('who', 'Who'),
+    card.apps.length ? `Where: ${card.apps.join(', ')}` : null,
+    card.screen ? `Screen: ${card.screen}` : null,
+    line('how', 'How it works'),
+    line('steps', 'Steps'),
+    line('now', 'Now'),
+    line('expected', 'Expected'),
+    card.details ? `Details: ${shorten(card.details.replace(/\s+/g, ' '), 300)}` : null,
+    card.doneWhen.length ? `Done when:\n${card.doneWhen.map(check => `  - ${check}`).join('\n')}` : null,
+    assumptions.length ? `Assumed (say if wrong):\n${assumptions.map(item => `  - ${item}`).join('\n')}` : null,
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+const questionFor = (field, type) => {
+  if (field === 'what') return { header: 'Task', question: QUESTIONS.what[type] }
+  if (field === 'who') return QUESTIONS.who
+  if (field === 'how') return QUESTIONS.how[type]
+  if (field === 'now') return QUESTIONS.now[type]
+  if (field === 'steps') return QUESTIONS.steps
+  return null
+}
+
+const checkTask = (input, { graph, search }) => {
+  const card = normalize(input || {})
+  const repoNames = new Set(graph.repos.map(repo => repo.name))
+  card.apps = card.apps.map(app => (/no screen change|backend/i.test(app) ? BACKEND_ONLY : app))
+  const otherPlaces = card.apps.filter(app => app !== BACKEND_ONLY && !repoNames.has(app))
+  if (otherPlaces.length) {
+    card.where = [card.where, ...otherPlaces].filter(Boolean).join('; ')
+    card.apps = card.apps.filter(app => !otherPlaces.includes(app))
+  }
+
+  if (!card.what) {
+    return {
+      status: 'needs_answers',
+      card: { ...card, round: card.round + 1 },
+      questions: [{ field: 'what', multiSelect: false, options: [], header: 'Task', question: 'What should change? One or two sentences, or paste the ticket.' }],
+      assumptions: [],
+    }
+  }
+
+  const questions = []
+  const assumptions = []
+  const ask = (field, question) => {
+    if ((card.asked[field] || 0) >= MAX_ASKS) {
+      assumptions.push(`Not given: ${question.question}`)
+      return
+    }
+    questions.push({ field, multiSelect: false, options: [], ...question })
+  }
+
+  const fromDetails = fromTicket(card)
+  if (fromDetails.length) assumptions.push(`Taken from the ticket text: ${fromDetails.join(', ')}`)
+
+  if (!card.type) {
+    card.type = guessType(taskText(card))
+    assumptions.push(`Type: ${card.type} (from the wording)`)
+  }
+
+  const result = search.find(taskText(card), { limit: 30, title: card.what })
+
+  let askedApps = false
+  if (!card.apps.length) {
+    const named = namedApps(card, graph)
+    const candidates = repoScores(result, graph)
+    const apps = candidates.filter(repo => repo.kind === 'app')
+    const backend = candidates.filter(repo => repo.kind !== 'app')
+    const backendFirst = backend.length && (!apps.length || backend[0].score >= apps[0].score * BACKEND_LEAD)
+    const pool = apps.length ? apps : candidates.filter(repo => repo.kind === 'api')
+    const close = pool.filter(repo => pool.length && repo.score >= pool[0].score * 0.35)
+    const others = graph.repos.filter(repo => repo.kind === 'app').map(repo => ({ name: repo.name, kind: repo.kind, score: 0 }))
+    const scored = [...new Map([...close, ...pool].map(repo => [repo.name, repo])).values()]
+    const offer = (scored.length >= 2 ? scored : [...new Map([...scored, ...others].map(repo => [repo.name, repo])).values()]).slice(0, 3)
+    if (named.length) {
+      card.apps = named
+    } else if (backendFirst && (card.asked.apps || 0) >= MAX_ASKS) {
+      card.apps = backend.filter(repo => repo.score >= backend[0].score * 0.35).map(repo => repo.name)
+      assumptions.push(`No screen change: ${card.apps.join(', ')} (closest match in the code)`)
+    } else if (offer.length >= 2 && (card.asked.apps || 0) < MAX_ASKS) {
+      askedApps = true
+      ask('apps', {
+        header: 'App',
+        question: 'Which app is this about?',
+        multiSelect: true,
+        options: [
+          ...offer.slice(0, 3).map(repo => ({
+            label: repo.name,
+            value: repo.name,
+            description: result.files.some(file => file.repo === repo.name)
+              ? `${KIND_LABELS[repo.kind]} · best match: ${humanize(Path.basename(screenOf(result.files.find(file => file.repo === repo.name).path)))}`
+              : KIND_LABELS[repo.kind],
+          })),
+          ...(apps.length || backendFirst ? [{ label: 'No screen change', value: BACKEND_ONLY, description: 'Only the API / background jobs change' }] : []),
+        ],
+      })
+    } else if (pool.length) {
+      card.apps = [pool[0].name]
+      assumptions.push(`App: ${pool[0].name} (closest match in the code)`)
+    }
+  }
+
+  if (card.apps.includes(BACKEND_ONLY)) {
+    card.apps = graph.repos.filter(repo => repo.kind !== 'app').map(repo => repo.name)
+  }
+
+  if (!filled(card, 'what')) ask('what', questionFor('what', card.type))
+  TEMPLATES[card.type]
+    .filter(field => !['what', 'where'].includes(field))
+    .filter(field => !(card.type === 'bug' && (field === 'now' || field === 'expected')))
+    .filter(field => !filled(card, field))
+    .forEach(field => ask(field, questionFor(field, card.type)))
+  if (card.type === 'bug' && (!filled(card, 'now') || !filled(card, 'expected'))) {
+    ask('now, expected', QUESTIONS['now, expected'])
+  }
+
+  if (!askedApps && card.apps.length && !card.screen) {
+    const screens = screenCandidates(search.find(taskText(card), { limit: 30, repos: card.apps, title: card.what }), graph, card.apps)
+    if (screens.length === 1 || (screens.length > 1 && screens[0].score >= screens[1].score * 1.6)) {
+      card.screen = `${screens[0].label} (${screens[0].description})`
+      assumptions.push(`Screen: ${card.screen}`)
+    }
+  }
+
+  const titleWords = new Set(words(card.what))
+  const unknown = result.unknown.filter(word =>
+    word.length >= 4 && titleWords.has(word) && !BUG_WORDS.test(word) && !FEATURE_WORDS.test(word) && !COMMON_VERBS.test(word))
+  if (unknown.length && !card.asked.words) {
+    ask('words', {
+      target: 'details',
+      header: 'Words',
+      question: `The code never uses "${unknown.join('", "')}". What is it called on screen or in the code, if you know?`,
+    })
+  }
+
+  const open = questions.slice(0, MAX_QUESTIONS)
+  if (!open.length || card.skip) {
+    questions.forEach(question => assumptions.push(`Not answered: ${question.question}`))
+    return { status: 'ready', card, assumptions, summary: summaryOf(card, assumptions), suggestChecks: !card.doneWhen.length }
+  }
+
+  const asked = { ...card.asked }
+  open.forEach(question => {
+    asked[question.field] = (asked[question.field] || 0) + 1
+  })
+  return {
+    status: 'needs_answers',
+    card: { ...card, round: card.round + 1, asked },
+    questions: open,
+    assumptions,
+  }
+}
+
+module.exports = {
+  checkTask,
+  taskText,
+  BACKEND_ONLY,
+}

package/src/task/conventions.js

@@ -0,0 +1,113 @@
+'use strict'
+
+const Path = require('path').posix
+const { TEST_FILE } = require('../shared')
+
+const KIND_FILE = /^(.+?)\.([a-z][a-z0-9-]*)\.([a-z]+)$/
+const MIN_KIND = 3
+const MAX_KINDS = 7
+const KIND_LABELS = { app: 'web or mobile app', api: 'API', shared: 'shared code' }
+const TOOL_FILES = [
+  ['ESLint', /^(eslint\.config\.[cm]?js|\.eslintrc(\.(js|cjs|json|ya?ml))?)$/],
+  ['Prettier', /^(\.prettierrc(\.(js|cjs|json|ya?ml))?|prettier\.config\.[cm]?js)$/],
+  ['EditorConfig', /^\.editorconfig$/],
+  ['TypeScript', /^tsconfig\.json$/],
+]
+
+const styleOf = stem => {
+  if (/^[a-z0-9]+(-[a-z0-9]+)+$/.test(stem)) return 'kebab-case'
+  if (/^[a-z0-9]+(_[a-z0-9]+)+$/.test(stem)) return 'snake_case'
+  if (/^[a-z]+[a-z0-9]*[A-Z][A-Za-z0-9]*$/.test(stem)) return 'camelCase'
+  if (/^[A-Z][A-Za-z0-9]*$/.test(stem)) return 'PascalCase'
+  if (/^[a-z0-9]+$/.test(stem)) return 'lowercase'
+  return null
+}
+
+const majority = values => {
+  const counts = new Map()
+  values.filter(Boolean).forEach(value => counts.set(value, (counts.get(value) || 0) + 1))
+  return [...counts.entries()].sort((a, b) => b[1] - a[1])[0] || [null, 0]
+}
+
+const folderOf = (path, stem) => {
+  const dir = Path.dirname(path)
+  return [stem, stem.split('.')[0]].includes(Path.basename(dir)) ? `${Path.dirname(dir)}/<name>` : dir
+}
+
+const kindsOf = files => {
+  const groups = new Map()
+  files.forEach(file => {
+    const match = Path.basename(file.path).match(KIND_FILE)
+    if (!match || TEST_FILE.test(file.path)) return
+    const key = `.${match[2]}.${match[3]}`
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key).push({ path: file.path, stem: match[1] })
+  })
+  return [...groups.entries()]
+    .filter(([, items]) => items.length >= MIN_KIND)
+    .sort((a, b) => b[1].length - a[1].length)
+    .slice(0, MAX_KINDS)
+    .map(([suffix, items]) => {
+      const folders = new Map()
+      items.forEach(item => {
+        const folder = folderOf(item.path, item.stem)
+        folders.set(folder, (folders.get(folder) || 0) + 1)
+      })
+      const ranked = [...folders.entries()].sort((a, b) => b[1] - a[1])
+      const [folder, count] = ranked[0]
+      const places = count >= items.length / 2 || ranked.length < 2 ? folder : `${folder} (${count}), ${ranked[1][0]} (${ranked[1][1]}) and others`
+      const [style] = majority(items.map(item => styleOf(item.stem)).filter(value => value !== 'lowercase'))
+      const example = items.filter(item => folderOf(item.path, item.stem) === folder).sort((a, b) => a.path.length - b.path.length)[0] || items[0]
+      return { suffix, count: items.length, folder: places, style, example: example.path }
+    })
+}
+
+const testsOf = files => {
+  const tests = files.filter(file => TEST_FILE.test(file.path))
+  if (!tests.length) return null
+  const [pattern] = majority(tests.map(file => {
+    const base = Path.basename(file.path)
+    const match = base.match(/\.(spec|test)\.[^.]+$/)
+    const top = file.path.split('/').find(part => /^(tests?|__tests__|spec)$/.test(part))
+    return top ? `${top}/ folder, named *${match ? match[0] : ''}` : `next to the file, named *${match ? match[0] : ''}`
+  }))
+  return { count: tests.length, pattern }
+}
+
+const toolsOf = repoIndex =>
+  TOOL_FILES.filter(([, pattern]) => (repoIndex.files || []).some(file => !file.path.includes('/') && pattern.test(file.path))).map(([name]) => name)
+
+const repoConventions = (repo, repoIndex, files) => {
+  const kinds = kindsOf(files)
+  const tests = testsOf(files)
+  const aliases = (repoIndex.aliases || []).map(alias => alias.from).filter(from => from !== './').slice(0, 6)
+  const tools = toolsOf(repoIndex)
+  const lines = []
+  kinds.forEach(kind => {
+    lines.push(`  ${kind.suffix.padEnd(16)} ${String(kind.count).padStart(4)} files in ${kind.folder}${kind.style ? `, ${kind.style}` : ''} · like ${kind.example}`)
+  })
+  if (tests) lines.push(`  tests: ${tests.count}, ${tests.pattern}`)
+  if (aliases.length) lines.push(`  imports use the aliases ${aliases.join(', ')}`)
+  if (tools.length) lines.push(`  checked with ${tools.join(', ')} (changed files must pass)`)
+  return lines
+}
+
+const conventionsFor = (graph, index, { focus = [] } = {}) => {
+  const byName = new Map(Object.values(index.repos || {}).map(repo => [repo.name, repo]))
+  const lines = ['HOW THIS PROJECT IS BUILT']
+  graph.repos.forEach(repo => {
+    const repoIndex = byName.get(repo.name) || { files: [], aliases: [] }
+    const files = graph.files.filter(file => file.repo === repo.name)
+    lines.push(`${repo.name} (${KIND_LABELS[repo.kind] || repo.kind}, ${files.length} code files${repoIndex.packageName ? `, package ${repoIndex.packageName}` : ''})`)
+    if (!focus.length || focus.includes(repo.name)) lines.push(...repoConventions(repo, repoIndex, files))
+  })
+  lines.push('New code copies the structure, naming and style of the files named above; new files go where files of the same kind live.')
+  return lines
+}
+
+module.exports = {
+  KIND_FILE,
+  styleOf,
+  majority,
+  conventionsFor,
+}

package/src/task/gate.js

@@ -0,0 +1,88 @@
+'use strict'
+
+const Path = require('path')
+
+const WAITING = ['plan-review', 'pm-review', 'changes-requested']
+const WAITING_HOURS = 12
+
+const STATUS = {
+  'plan-review': 'waiting for the developer to approve the plan',
+  'pm-review': 'waiting for PM approval',
+  'changes-requested': 'sent back for changes',
+}
+
+const { TEST_FILE } = require('../shared')
+
+const inside = (file, dir) => file === dir || file.startsWith(`${dir}${Path.sep}`)
+
+const repoOf = (file, repos) =>
+  repos
+    .filter(repo => inside(file, repo.path))
+    .sort((a, b) => b.path.length - a.path.length)[0] || null
+
+const label = (taskKey, ticket) => (ticket ? `${ticket} (${taskKey})` : taskKey)
+
+const checkEdit = ({ file, repos, active, tasks, currentBranch, now = Date.now() }) => {
+  const repo = repoOf(file, repos)
+  if (!repo) return { allow: true }
+  const relative = Path.relative(repo.path, file).split(Path.sep).join('/')
+  const key = `${repo.name}/${relative}`
+
+  const projectBuilds = Object.entries(active).filter(([, build]) => String(build.projectId) === String(repo.projectId))
+  const builds = projectBuilds.filter(([, build]) => build.repos.some(entry => entry.name === repo.name))
+  if (projectBuilds.length && !builds.length) {
+    const [taskKey, build] = projectBuilds[0]
+    return {
+      allow: false,
+      reason: `tspl: ${repo.name} is not part of the approved build for ${label(taskKey, build.ticket)} (${build.repos.map(entry => entry.name).join(', ')}). If it has to change, stop and tell the user, then submit a new plan version for approval.`,
+    }
+  }
+  if (builds.length) {
+    const [taskKey, build] = builds.find(([, entry]) => entry.files.includes(key)) || builds[0]
+    const branch = currentBranch(repo.path)
+    if (branch && branch !== build.branch) {
+      return {
+        allow: false,
+        reason: `tspl: ${repo.name} is on branch "${branch}", but the approved build for ${label(taskKey, build.ticket)} works on "${build.branch}". Switch first: git -C ${repo.path} switch ${build.branch}`,
+      }
+    }
+    if (!build.files.includes(key) && !TEST_FILE.test(relative)) {
+      return {
+        allow: false,
+        reason: `tspl: ${key} is not on the approved checklist for ${label(taskKey, build.ticket)}. If it has to change, stop and tell the user, then submit a new plan version for approval.`,
+      }
+    }
+    return { allow: true }
+  }
+
+  const waiting = tasks
+    .filter(task => String(task.projectId) === String(repo.projectId) && WAITING.includes(task.status))
+    .filter(task => now - new Date(task.updatedAt || task.createdAt || 0).getTime() < WAITING_HOURS * 3600 * 1000)
+    .sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0))[0]
+  if (waiting) {
+    return {
+      allow: false,
+      reason: `tspl: task ${label(waiting.id, waiting.card && waiting.card.ticket)} is ${STATUS[waiting.status]}; no code changes until its plan is approved (tspl plan show ${waiting.id}). To drop the task: tspl build stop ${waiting.id}`,
+    }
+  }
+  return { allow: true }
+}
+
+const checkFiles = ({ taskKey, build, repoName, branch, files }) => {
+  const reasons = []
+  const name = label(taskKey, build.ticket)
+  if (branch && branch !== build.branch) {
+    reasons.push(`tspl: ${repoName} is on branch "${branch}", but the approved build for ${name} works on "${build.branch}".`)
+  }
+  const off = files.filter(file => !build.files.includes(`${repoName}/${file}`) && !TEST_FILE.test(file))
+  if (off.length) {
+    reasons.push(`tspl: not on the approved checklist for ${name}: ${off.join(', ')}. Submit a new plan version for approval, or stop the task: tspl build stop ${taskKey}`)
+  }
+  return { allow: !reasons.length, reasons }
+}
+
+module.exports = {
+  TEST_FILE,
+  checkEdit,
+  checkFiles,
+}