tspl-cli 0.0.0-stage → 0.1.1

package/src/project-config.js

@@ -0,0 +1,197 @@
+'use strict'
+
+const Fs = require('fs')
+const Path = require('path')
+const { validateProjectConfig, validateCheck, hashValue } = require('./shared')
+
+const { identify } = require('./git-helper')
+
+const CONFIG_DIR = '.tspl'
+const CONFIG_FILE = 'project.json'
+const INSTRUCTIONS_FILE = 'instructions.md'
+
+const inside = (dir, parent) => dir === parent || dir.startsWith(`${parent}${Path.sep}`)
+
+const real = file => {
+  try {
+    return Fs.realpathSync(file)
+  } catch (err) {
+    if (err.code === 'ENOENT') return null
+    throw err
+  }
+}
+
+const readConfigFile = root => {
+  const file = Path.join(root, CONFIG_DIR, CONFIG_FILE)
+  let parsed
+  try {
+    parsed = JSON.parse(Fs.readFileSync(file, 'utf8'))
+  } catch (err) {
+    throw new Error(`Cannot read ${file}: ${err.message}`)
+  }
+  try {
+    return validateProjectConfig(parsed)
+  } catch (err) {
+    throw new Error(`${file} is not valid: ${err.message}`)
+  }
+}
+
+/** The folder the repo paths are relative to: the manifest folder, or its parent when the manifest lives in one child repo. */
+const workspaceRoot = (root, config) => {
+  if (!config.home) return root
+  if (Path.basename(root) !== config.home) {
+    throw new Error(`The project file says it lives in "${config.home}" but it was found in ${root}.`)
+  }
+  return Path.dirname(root)
+}
+
+const childManifest = (dir, start) => {
+  let entries
+  try {
+    entries = Fs.readdirSync(dir, { withFileTypes: true })
+  } catch (err) {
+    return null
+  }
+  for (const entry of entries.filter(item => item.isDirectory() && !item.name.startsWith('.')).sort((a, b) => a.name.localeCompare(b.name))) {
+    const root = Path.join(dir, entry.name)
+    if (!Fs.existsSync(Path.join(root, CONFIG_DIR, CONFIG_FILE))) continue
+    let config
+    try {
+      config = readConfigFile(root)
+    } catch (err) {
+      continue
+    }
+    if (config.home !== entry.name) continue
+    const belongs = start === dir || config.repos.some(repo => inside(start, Path.resolve(dir, repo.path)))
+    if (belongs) return { root, workspace: dir, config }
+  }
+  return null
+}
+
+const findProjectConfig = cwd => {
+  const start = real(Path.resolve(cwd))
+  let dir = start
+  while (dir) {
+    if (Fs.existsSync(Path.join(dir, CONFIG_DIR, CONFIG_FILE))) {
+      const config = readConfigFile(dir)
+      return { root: dir, workspace: workspaceRoot(dir, config), config }
+    }
+    if (!Fs.existsSync(Path.join(dir, '.git'))) {
+      const nested = childManifest(dir, start)
+      if (nested) return nested
+    }
+    const parent = Path.dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+  return null
+}
+
+const sameIdentity = (expected, actual) =>
+  Boolean(
+    (expected.fingerprint && expected.fingerprint === actual.fingerprint) ||
+      (expected.remoteHash && expected.remoteHash === actual.remoteHash),
+  )
+
+/**
+ * Maps each repo of the project file to a local checkout. The default location comes from the
+ * committed relative path; a personal link may point elsewhere. Either way the checkout must be
+ * the repository the project file names, so two projects with equally named repos never mix.
+ */
+const resolveRepoPaths = (root, config, links, deps = {}) => {
+  const identifyRepo = deps.identify || identify
+  const rootReal = real(workspaceRoot(root, config))
+  if (links && links.projectId && links.projectId !== config.project.id) {
+    throw new Error(`The local links belong to another project (identity mismatch for ${config.organization}/${config.project.slug}).`)
+  }
+  const map = new Map()
+  config.repos.forEach(repo => {
+    const override = links && links.repos && links.repos[repo.id] && links.repos[repo.id].path
+    let target
+    if (override && Fs.existsSync(override)) {
+      target = real(override)
+    } else {
+      const candidate = real(Path.resolve(rootReal, repo.path))
+      if (candidate && !inside(candidate, rootReal)) {
+        throw new Error(`${repo.name}: ${repo.path} resolves outside the workspace.`)
+      }
+      target = candidate
+    }
+    if (!target) return
+    if (!sameIdentity(repo, identifyRepo(target))) {
+      throw new Error(`${repo.name}: the checkout at ${target} does not match the repository identity in the project file.`)
+    }
+    map.set(repo.name, target)
+  })
+  return map
+}
+
+const readProjectInstructions = (root, config) => {
+  const rootReal = real(root)
+  const files = config.instructions.map(relative => {
+    const file = real(Path.resolve(rootReal, relative))
+    if (!file) throw new Error(`Instruction file ${relative} is missing. Restore it or remove it from ${CONFIG_DIR}/${CONFIG_FILE}.`)
+    if (!inside(file, rootReal)) throw new Error(`Instruction file ${relative} resolves outside the project.`)
+    return { path: relative, content: Fs.readFileSync(file, 'utf8') }
+  })
+  return {
+    text: files.map(file => file.content.trim()).filter(Boolean).join('\n\n'),
+    hash: hashValue(files),
+  }
+}
+
+/** Project rules for briefs; empty for a folder without a project file. A broken file is an error, not silence. */
+const projectInstructionsText = cwd => {
+  const found = findProjectConfig(cwd)
+  return found ? readProjectInstructions(found.root, found.config).text : ''
+}
+
+const snapshotProject = (root, config, taskTests = {}) => {
+  const names = config.repos.map(repo => repo.name)
+  const taskChecks = (taskTests.checks || []).map((check, i) =>
+    validateCheck({ attested: false, criteria: [], ...check }, names, `taskTests.checks[${i}]`),
+  )
+  const ids = new Set(config.checks.map(check => check.id))
+  taskChecks.forEach(check => {
+    if (ids.has(check.id)) throw new Error(`Duplicate check id "${check.id}" between the project and the task tests.`)
+    ids.add(check.id)
+  })
+  return {
+    version: 1,
+    configHash: hashValue(config),
+    checks: [...config.checks, ...taskChecks],
+    manualCriteria: [...(taskTests.manualCriteria || [])],
+    acceptance: taskTests.acceptance || 0,
+    maxRepairRounds: config.workflow.maxRepairRounds,
+    instructionsHash: readProjectInstructions(root, config).hash,
+    repos: config.repos,
+  }
+}
+
+const writeFileSafely = (file, content) => {
+  Fs.mkdirSync(Path.dirname(file), { recursive: true })
+  const temp = `${file}.${process.pid}.tmp`
+  Fs.writeFileSync(temp, content)
+  Fs.renameSync(temp, file)
+}
+
+const writeProjectConfig = (root, config, instructions) => {
+  const dir = Path.join(root, CONFIG_DIR)
+  writeFileSafely(Path.join(dir, CONFIG_FILE), `${JSON.stringify(validateProjectConfig(config), null, 2)}\n`)
+  if (instructions !== undefined && instructions !== null) writeFileSafely(Path.join(dir, INSTRUCTIONS_FILE), instructions)
+  const ignore = Path.join(dir, '.gitignore')
+  if (!Fs.existsSync(ignore)) writeFileSafely(ignore, 'local/\n*.local.json\n*.log\n')
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  INSTRUCTIONS_FILE,
+  workspaceRoot,
+  findProjectConfig,
+  resolveRepoPaths,
+  readProjectInstructions,
+  projectInstructionsText,
+  snapshotProject,
+  writeProjectConfig,
+}

package/src/project-init.js

@@ -0,0 +1,447 @@
+'use strict'
+
+const Fs = require('fs')
+const Path = require('path')
+const { TEST_CATEGORIES, validateProjectConfig, WORKFLOW_DEFAULTS } = require('./shared')
+
+const { ensureBrowserTests } = require('./browser-tests')
+const { remoteUrl, normalizeGitUrl } = require('./git-helper')
+const {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  INSTRUCTIONS_FILE,
+  findProjectConfig,
+  resolveRepoPaths,
+  workspaceRoot,
+  writeProjectConfig,
+} = require('./project-config')
+
+const REFERENCE_START = '<!-- tspl:project:start -->'
+const REFERENCE_END = '<!-- tspl:project:end -->'
+const INSTRUCTION_FILES = ['CLAUDE.md', 'AGENTS.md', 'GEMINI.md', '.cursorrules', '.github/copilot-instructions.md']
+const PLACEHOLDER_SCRIPT = /no test specified|exit\s+1\s*$|^\s*echo\b/i
+const SCRIPTS = [
+  ['test', 'unit'],
+  ['test:unit', 'unit'],
+  ['test:integration', 'integration'],
+  ['test:e2e', 'e2e'],
+  ['e2e', 'e2e'],
+  ['lint', 'lint'],
+  ['typecheck', 'typecheck'],
+  ['type-check', 'typecheck'],
+  ['build', 'build'],
+]
+
+const readJson = file => {
+  try {
+    return JSON.parse(Fs.readFileSync(file, 'utf8'))
+  } catch (err) {
+    return null
+  }
+}
+
+const packageManager = dir => {
+  const pkg = readJson(Path.join(dir, 'package.json')) || {}
+  if (typeof pkg.packageManager === 'string') return pkg.packageManager.split('@')[0]
+  if (Fs.existsSync(Path.join(dir, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (Fs.existsSync(Path.join(dir, 'yarn.lock'))) return 'yarn'
+  if (Fs.existsSync(Path.join(dir, 'bun.lockb')) || Fs.existsSync(Path.join(dir, 'bun.lock'))) return 'bun'
+  return 'npm'
+}
+
+const workspaceDirs = repoPath => {
+  const pkg = readJson(Path.join(repoPath, 'package.json'))
+  const globs = pkg && (Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces && pkg.workspaces.packages) || []
+  const dirs = []
+  globs.forEach(glob => {
+    const clean = String(glob).replace(/\/+$/, '')
+    if (clean.endsWith('/*')) {
+      const parent = Path.join(repoPath, clean.slice(0, -2))
+      if (!Fs.existsSync(parent)) return
+      Fs.readdirSync(parent, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && Fs.existsSync(Path.join(parent, entry.name, 'package.json')))
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .forEach(entry => dirs.push(Path.posix.join(clean.slice(0, -2), entry.name)))
+    } else if (!clean.includes('*') && Fs.existsSync(Path.join(repoPath, clean, 'package.json'))) {
+      dirs.push(clean)
+    }
+  })
+  return dirs
+}
+
+const command = (manager, script) => {
+  if (script === 'test') return `${manager} test`
+  return `${manager} ${manager === 'yarn' ? '' : 'run '}${script}`.replace('  ', ' ')
+}
+
+const parserFor = (category, script) => {
+  if (!TEST_CATEGORIES.includes(category)) return { parser: 'exit-code', needsAttestation: false }
+  if (/node\s+(--[\w-]+\s+)*--test\b/.test(script)) return { parser: 'node-tap', needsAttestation: false }
+  if (/\bjest\b/.test(script)) return { parser: 'jest-json', needsAttestation: false }
+  return { parser: 'custom', needsAttestation: true }
+}
+
+const slug = value => value.replace(/[^a-z0-9]+/gi, '-').replace(/^-|-$/g, '').toLowerCase()
+
+const fromPackage = (repoPath, cwd, manager, workspaces) => {
+  const pkg = readJson(Path.join(repoPath, cwd, 'package.json'))
+  if (!pkg || !pkg.scripts) return []
+  const found = []
+  SCRIPTS.forEach(([name, category]) => {
+    const script = pkg.scripts[name]
+    if (typeof script !== 'string' || !script.trim()) return
+    if (PLACEHOLDER_SCRIPT.test(script.trim())) return
+    if (cwd === '.' && workspaces && /--workspaces|\s-ws\b|--workspace\b|\bworkspaces\b/.test(script)) return
+    if (found.some(item => item.category === category && category !== 'unit')) return
+    if (found.some(item => item.category === 'unit') && category === 'unit' && name !== 'test') return
+    const { parser, needsAttestation } = parserFor(category, script)
+    found.push({
+      id: `${category}${cwd === '.' ? '' : `-${slug(cwd)}`}`,
+      repo: '',
+      cwd,
+      category,
+      command: command(manager, name),
+      timeoutMs: WORKFLOW_DEFAULTS.checkTimeoutMs,
+      required: true,
+      parser,
+      attested: false,
+      criteria: [],
+      needsAttestation,
+      script,
+    })
+  })
+  return found
+}
+
+const PLAYWRIGHT_CONFIG = /^playwright\.config\.[cm]?[jt]s$/
+
+/** A Playwright setup becomes a browser check that reports each test case and keeps its screenshots and videos. */
+const playwrightCheck = (repoPath, cwd) => {
+  const dir = Path.join(repoPath, cwd)
+  const pkg = readJson(Path.join(dir, 'package.json')) || {}
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  let hasConfig = false
+  try {
+    hasConfig = Fs.readdirSync(dir).some(name => PLAYWRIGHT_CONFIG.test(name))
+  } catch (err) {
+    hasConfig = false
+  }
+  if (!deps['@playwright/test'] && !hasConfig) return null
+  return {
+    id: `e2e-browser${cwd === '.' ? '' : `-${slug(cwd)}`}`,
+    repo: '',
+    cwd,
+    category: 'e2e',
+    command: 'npx playwright test --reporter=json',
+    timeoutMs: WORKFLOW_DEFAULTS.checkTimeoutMs,
+    required: true,
+    parser: 'playwright-json',
+    attested: false,
+    criteria: [],
+    artifacts: 'test-results',
+    needsAttestation: false,
+    script: 'playwright test',
+  }
+}
+
+/** Reads package scripts without running them. Checks with needsAttestation use a test runner tspl cannot count. */
+const discoverChecks = repoPath => {
+  const manager = packageManager(repoPath)
+  const dirs = workspaceDirs(repoPath)
+  const hasWorkspaces = dirs.length > 0
+  const found = [
+    ...fromPackage(repoPath, '.', manager, hasWorkspaces),
+    ...dirs.flatMap(dir => fromPackage(repoPath, dir, manager, false)),
+  ]
+  ;['.', ...dirs].forEach(cwd => {
+    const browser = playwrightCheck(repoPath, cwd)
+    if (!browser) return
+    // a script that already runs Playwright is replaced by the reporting command
+    const index = found.findIndex(check => check.cwd === cwd && /playwright/.test(check.script))
+    if (index !== -1) found.splice(index, 1)
+    found.push(browser)
+  })
+  return found
+}
+
+/** Web apps without browser tests get Playwright set up, unless the user said --no-e2e. Returns the folders set up. */
+const setUpBrowserTests = (repoPath, deps, options) => {
+  if (options.e2e === false) return []
+  const manager = packageManager(repoPath)
+  const installed = []
+  ;['.', ...workspaceDirs(repoPath)].forEach(cwd => {
+    const dir = Path.join(repoPath, cwd)
+    const result = ensureBrowserTests(dir, manager, deps.run, deps.log)
+    if (result.status === 'installed') installed.push(dir)
+    if (result.status === 'failed') (deps.log || console.log)(`  ! Browser tests were not set up in ${dir}: ${result.reason}. Run tspl init again to retry, or --no-e2e to skip.`)
+  })
+  return installed
+}
+
+const githubRepository = dir => {
+  const url = remoteUrl(dir)
+  if (!url) return null
+  const match = normalizeGitUrl(url).match(/^github\.com\/([^/]+\/[^/]+)$/)
+  return match ? match[1] : null
+}
+
+const existingInstructionFiles = (root, repoPaths) => {
+  const found = []
+  const candidates = [root, ...repoPaths.filter(dir => dir !== root && dir.startsWith(`${root}${Path.sep}`))]
+  candidates.forEach(dir => {
+    INSTRUCTION_FILES.forEach(name => {
+      if (Fs.existsSync(Path.join(dir, name))) found.push(Path.relative(root, Path.join(dir, name)).split(Path.sep).join('/'))
+    })
+  })
+  return found
+}
+
+const DEFAULT_INSTRUCTIONS = [
+  '# Project instructions for tspl',
+  '',
+  'These rules apply to every AI-assisted task in this project. They add to, and never weaken, the project\'s',
+  'existing instruction files and the permissions enforced by the tspl API.',
+  '',
+  '## Ready for review means',
+  '',
+  '- Every required check in `.tspl/project.json` ran on the exact commits of the pull request and passed.',
+  '- A separate review of the same commits passed.',
+  '- Required CI checks on the pull request passed for those commits.',
+  '',
+  '## Rules',
+  '',
+  '- Keep to the approved plan; ask for a plan change instead of editing other files.',
+  '- Add or update tests for the behaviour you change.',
+  '',
+].join('\n')
+
+const readiness = (config, localPaths) => {
+  const problems = []
+  const warnings = []
+  if (!config.checks.some(check => check.required && TEST_CATEGORIES.includes(check.category))) {
+    problems.push('No required test check is configured. Add one to .tspl/project.json (category unit, integration or e2e); a tested PR needs it.')
+  }
+  config.repos.forEach(repo => {
+    if (!localPaths.has(repo.name)) problems.push(`Repo ${repo.name} is not cloned on this machine.`)
+    if (!config.checks.some(check => check.repo === repo.name)) warnings.push(`Repo ${repo.name} has no checks.`)
+    if (repo.delivery.provider !== 'github') warnings.push(`Repo ${repo.name}: automatic pull requests need GitHub; other providers only get a compare link.`)
+  })
+  return { ready: problems.length === 0, problems, warnings }
+}
+
+const describeChange = (before, after) => {
+  const lines = []
+  const ids = new Set(before.checks.map(check => check.id))
+  after.checks.filter(check => !ids.has(check.id)).forEach(check => lines.push(`+ check ${check.id}: ${check.command} (${check.repo}, ${check.cwd})`))
+  const names = new Set(before.repos.map(repo => repo.name))
+  after.repos.filter(repo => !names.has(repo.name)).forEach(repo => lines.push(`+ repo ${repo.name} at ${repo.path}`))
+  const files = new Set(before.instructions)
+  after.instructions.filter(file => !files.has(file)).forEach(file => lines.push(`+ instructions ${file}`))
+  return lines
+}
+
+const ask = async (deps, options, message, fallback) => (options.yes ? fallback : deps.prompts.confirm({ message, default: fallback }))
+
+const buildChecks = async (repo, discovered, deps, options) => {
+  const chosen = []
+  for (const found of discovered) {
+    const label = `${repo.name}: ${found.command}${found.cwd === '.' ? '' : ` (in ${found.cwd})`} [${found.category}]`
+    if (!(await ask(deps, options, `Use this check? ${label}`, !found.needsAttestation))) continue
+    let attested = false
+    if (found.needsAttestation) {
+      attested = !options.yes && (await deps.prompts.confirm({
+        message: `tspl cannot count test results for "${found.script}". Confirm this command really runs tests and exits non-zero when one fails?`,
+        default: false,
+      }))
+      if (!attested) continue
+    }
+    const { needsAttestation, script, ...check } = found
+    chosen.push({ ...check, repo: repo.name, id: `${check.id}-${repo.name}`, attested })
+  }
+  return chosen
+}
+
+const referenceBlock = '\n\nProject rules for AI-assisted tasks are kept in `.tspl/instructions.md` (managed by tspl).'
+
+const addManagedReference = file => {
+  const current = Fs.existsSync(file) ? Fs.readFileSync(file, 'utf8') : ''
+  if (current.includes(REFERENCE_START)) return false
+  Fs.writeFileSync(file, `${current.trimEnd()}${current.trim() ? '\n\n' : ''}${REFERENCE_START}${referenceBlock}\n${REFERENCE_END}\n`)
+  return true
+}
+
+const cancelled = (err, project) => {
+  if (err && err.name === 'ExitPromptError') {
+    return new Error(`Cancelled. No project files were written or changed.${project ? ` ${project.name} was already linked on this machine.` : ''}`)
+  }
+  return err
+}
+
+const isGit = dir => Fs.existsSync(Path.join(dir, '.git'))
+
+const chooseManifestHome = async (folder, linked, deps, options) => {
+  if (isGit(folder)) return { root: folder, home: undefined }
+  const repoDirs = linked.map(repo => repo.path).filter(dir => Path.dirname(dir) === folder)
+  let chosen = options.manifestHome ? Path.resolve(folder, options.manifestHome) : null
+  if (!chosen && !options.yes && repoDirs.length) {
+    chosen = await deps.prompts.select({
+      message: `${folder} is not a Git repository, so files saved there would not be shared. Which repository should hold the shared .tspl files?`,
+      choices: repoDirs.map(dir => ({ name: Path.basename(dir), value: dir })),
+    })
+  }
+  if (!chosen) return null
+  if (!repoDirs.includes(chosen)) throw new Error(`${chosen} is not one of the repositories in ${folder}.`)
+  return { root: chosen, home: Path.basename(chosen) }
+}
+
+const linkFromConfig = (project, root, config, deps) => {
+  const links = deps.links.read()
+  const key = `${deps.credentials.read().organization}/${project.slug}`
+  const paths = resolveRepoPaths(root, config, links[key])
+  const previous = links[key] || {}
+  const repos = { ...(previous.repos || {}) }
+  config.repos.forEach(repo => {
+    if (paths.has(repo.name)) repos[repo.id] = { name: repo.name, path: paths.get(repo.name) }
+  })
+  links[key] = { projectId: project._id, folder: previous.folder || workspaceRoot(root, config), repos, ignored: previous.ignored || [] }
+  deps.links.write(links)
+  return paths
+}
+
+/** Confirms with the server that a project file belongs to a project this user can see; a file never grants access. */
+const verifyServerIdentity = async (config, deps) => {
+  const credentials = deps.credentials.read()
+  if (credentials.organization !== config.organization) {
+    throw new Error(`This project belongs to organization "${config.organization}" but you are logged in to "${credentials.organization}".`)
+  }
+  let project
+  try {
+    project = await deps.request('GET', `/api/v1/projects/${encodeURIComponent(config.project.slug)}`)
+  } catch (err) {
+    if (err.statusCode === 404 || err.statusCode === 403) {
+      throw new Error(`The project file names project "${config.project.slug}", which you cannot access. Ask an owner, admin or PM to add you.`)
+    }
+    throw err
+  }
+  if (project._id !== config.project.id) {
+    throw new Error(`The project file's project id does not match "${config.project.slug}" on the server (identity mismatch).`)
+  }
+  const known = new Set((project.repos || []).map(repo => repo._id))
+  config.repos.forEach(repo => {
+    if (!known.has(repo.id)) throw new Error(`Repo ${repo.name} is not part of project ${config.project.slug} on the server (identity mismatch).`)
+  })
+  return project
+}
+
+/**
+ * Initializes (or re-adopts) the project in a folder. Machine login must exist; no project file can add access.
+ * Returns { root, config, created, readiness } or null when the user declined to create a project.
+ */
+const initializeProject = async (folderArg, options = {}, deps) => {
+  if (!deps.credentials.read().accessToken) throw new Error('You are not logged in. Run: tspl setup')
+  const folder = Fs.realpathSync(Path.resolve(folderArg || process.cwd()))
+
+  const existing = findProjectConfig(folder)
+  if (existing) {
+    const project = await verifyServerIdentity(existing.config, deps)
+    const paths = linkFromConfig(project, existing.root, existing.config, deps)
+    const discovered = []
+    let browserTestsAdded = false
+    for (const repo of existing.config.repos) {
+      const dir = paths.get(repo.name)
+      if (!dir) continue
+      if (setUpBrowserTests(dir, deps, options).length) browserTestsAdded = true
+      const known = new Set(existing.config.checks.filter(check => check.repo === repo.name).map(check => `${check.cwd}|${check.command}`))
+      const fresh = discoverChecks(dir).filter(check => !known.has(`${check.cwd}|${check.command}`))
+      discovered.push(...(await buildChecks(repo, fresh, deps, options)))
+    }
+    const merged = validateProjectConfig({ ...existing.config, checks: [...existing.config.checks, ...discovered.filter(check => !existing.config.checks.some(item => item.id === check.id))] })
+    const changes = describeChange(existing.config, merged)
+    let config = existing.config
+    if (changes.length) {
+      console.log(`Proposed changes to ${CONFIG_DIR}/${CONFIG_FILE}:\n${changes.map(line => `  ${line}`).join('\n')}`)
+      // browser tests tspl just set up are applied without asking again
+      if (await ask(deps, options, 'Apply them?', browserTestsAdded)) {
+        writeProjectConfig(existing.root, merged)
+        config = merged
+      }
+    }
+    return { root: existing.root, config, created: false, readiness: readiness(config, paths) }
+  }
+
+  const linked = await deps.setupProject(folder, options)
+  if (!linked) return null
+  const { project } = linked
+  const localRepos = linked.linked
+
+  try {
+    const manifest = await chooseManifestHome(folder, localRepos, deps, options)
+    if (!manifest) {
+      return {
+        root: null,
+        config: null,
+        created: false,
+        readiness: {
+          ready: false,
+          problems: [`${folder} is not a Git repository. Choose the repository that should hold the shared .tspl files (tspl init --manifest-home <repo>); tspl will not create a Git repository for you.`],
+          warnings: [],
+        },
+      }
+    }
+    const workspace = manifest.home ? folder : manifest.root
+
+    const repos = []
+    const checks = []
+    for (const local of localRepos) {
+      const delivery = githubRepository(local.path)
+      const repo = {
+        id: local._id,
+        name: local.name,
+        fingerprint: local.fingerprint || undefined,
+        remoteHash: local.remoteHash || undefined,
+        path: Path.relative(workspace, local.path).split(Path.sep).join('/') || '.',
+        delivery: { provider: delivery ? 'github' : 'manual', repository: delivery || local.name, requiredChecks: [], ciPolicy: 'discover' },
+      }
+      repos.push(repo)
+      setUpBrowserTests(local.path, deps, options)
+      checks.push(...(await buildChecks(repo, discoverChecks(local.path), deps, options)))
+    }
+
+    const instructionFiles = existingInstructionFiles(manifest.root, localRepos.map(repo => repo.path))
+    const config = validateProjectConfig({
+      schemaVersion: 1,
+      ...(manifest.home ? { home: manifest.home } : {}),
+      organization: deps.credentials.read().organization,
+      project: { id: project._id, slug: project.slug },
+      repos,
+      checks,
+      workflow: WORKFLOW_DEFAULTS,
+      instructions: [`${CONFIG_DIR}/${INSTRUCTIONS_FILE}`, ...instructionFiles],
+    })
+
+    const instructionsPath = Path.join(manifest.root, CONFIG_DIR, INSTRUCTIONS_FILE)
+    writeProjectConfig(manifest.root, config, Fs.existsSync(instructionsPath) ? undefined : DEFAULT_INSTRUCTIONS)
+    if (!options.yes && instructionFiles.length) {
+      for (const file of instructionFiles) {
+        if (await deps.prompts.confirm({ message: `Add a short, clearly marked pointer to the project rules in ${file}? Nothing else in it changes.`, default: false })) {
+          addManagedReference(Path.join(manifest.root, file))
+        }
+      }
+    }
+
+    const paths = resolveRepoPaths(manifest.root, config, deps.links.read()[`${config.organization}/${project.slug}`])
+    return { root: manifest.root, config, created: true, readiness: readiness(config, paths) }
+  } catch (err) {
+    throw cancelled(err, project)
+  }
+}
+
+module.exports = {
+  discoverChecks,
+  initializeProject,
+  addManagedReference,
+  readiness,
+  existingInstructionFiles,
+  REFERENCE_START,
+  REFERENCE_END,
+}