tspl-cli 0.0.0-stage → 0.1.1

package/src/workflow/runtime.js

@@ -0,0 +1,148 @@
+'use strict'
+
+const Fs = require('fs')
+const { confirm, input, search, select } = require('@inquirer/prompts')
+
+const { request } = require('../api-client')
+const { readActive, writeActive, readLinks, readCredentials, readRun, writeRun, readTask, writeTask } = require('../config-store')
+const { findProject } = require('../workspace')
+const { findProjectConfig, resolveRepoPaths, readProjectInstructions } = require('../project-config')
+const { prepareBuild, blockers, runBuild, refreshChecklist } = require('../task/build')
+const { askBranchChoice } = require('../task/branch-choice')
+const { removeHooks } = require('../task/hooks')
+const { engineFor } = require('../task/refine')
+const { reviewPlan, withSnapshot } = require('../task/plan')
+const { createProvider } = require('../providers')
+const { runChecks, captureHeads } = require('./evidence')
+const { implementTask, planTask, proposeTaskApproaches } = require('./agents')
+const { planningContext, planningBrief } = require('../task/planning-context')
+const { chooseForPlanning, renderApproaches } = require('../task/approaches')
+const { saveDraft, takeDraft } = require('../task/plan-draft')
+const { reviewTask } = require('./review')
+const { claimCheckouts } = require('./checkout-lock')
+const { workflowClient } = require('./client')
+const { gitOps } = require('./controller')
+
+const taskUrl = (projectId, key) => `/api/v1/projects/${projectId}/tasks/${encodeURIComponent(key)}`
+
+const load = async ({ cwd, taskId }) => {
+  const found = findProjectConfig(cwd)
+  if (!found) throw new Error('This folder has no .tspl/project.json. Run: tspl init')
+  const { project, repos } = await findProject(cwd)
+  if (project._id !== found.config.project.id) {
+    throw new Error(`The project file is for project ${found.config.project.slug} (${found.config.project.id}), but this folder is linked to ${project.slug}. Check .tspl/project.json.`)
+  }
+  const links = readLinks()[`${readCredentials().organization}/${project.slug}`]
+  const paths = resolveRepoPaths(found.root, found.config, links)
+  const missing = found.config.repos.filter(repo => !paths.has(repo.name)).map(repo => repo.name)
+  if (missing.length) throw new Error(`These repos are not cloned on this computer: ${missing.join(', ')}. Clone them, then run: tspl init`)
+  void repos
+  const task = await request('GET', taskUrl(project._id, taskId))
+  return {
+    projectId: project._id,
+    project,
+    root: found.root,
+    config: found.config,
+    paths,
+    instructions: readProjectInstructions(found.root, found.config).text,
+    task,
+  }
+}
+
+const finishLocal = taskKey => {
+  const active = readActive()
+  ;((active[taskKey] || {}).repos || []).forEach(repo => removeHooks(repo.path))
+  delete active[taskKey]
+  writeActive(active)
+  const local = readTask(taskKey)
+  if (local.id) writeTask({ ...local, status: 'done' })
+}
+
+/** Plans a task with the planning engine, checks the plan against the code and submits it for approval. */
+const plan = async (cwd, ctx, { interactive = Boolean(process.stdin.isTTY) } = {}) => {
+  const { createContext } = require('../mcp/server')
+  const loaded = await createContext(cwd).load()
+  const engine = engineFor('plan')
+  const choice = await chooseForPlanning(ctx.projectId, ctx.task.key, {
+    signal: ctx.signal,
+    generate: async task => {
+      const brief = planningContext(loaded, task, { paths: ctx.paths })
+      const { draftPlan, ...proposal } = await proposeTaskApproaches({ engine: engine.name, model: engine.model, task, brief, paths: ctx.paths, instructions: ctx.instructions, timeoutMs: ctx.config.workflow.engineTimeoutMs, signal: ctx.signal, withPlan: true })
+      if (draftPlan) saveDraft(ctx.projectId, task, proposal, draftPlan, brief)
+      return proposal
+    },
+    choose: interactive ? async approaches => {
+      console.log(renderApproaches(approaches))
+      return select({ message: 'Which implementation approach should the plan use?', choices: approaches.options.map(option => ({ value: option.id, name: `${option.title}${option.id === approaches.recommendedId ? ' (Recommended)' : ''}` })) }, { signal: ctx.signal })
+    } : null,
+  })
+  if (choice.waitingForSelection) return choice
+  ctx.task = choice.task
+  const { text: brief, files: briefFiles } = planningBrief(loaded, ctx.task, { paths: ctx.paths })
+  const proposed = await planTask({ engine: engine.name, model: engine.model, task: ctx.task, brief, draft: takeDraft(ctx.projectId, ctx.task, brief), paths: ctx.paths, instructions: ctx.instructions, timeoutMs: ctx.config.workflow.engineTimeoutMs, signal: ctx.signal })
+  const review = reviewPlan(proposed, ctx.task.card, loaded.graph, { briefFiles })
+  const version = ((ctx.task.plan && ctx.task.plan.version) || 0) + 1
+  ctx.signal?.throwIfAborted()
+  await request('PUT', taskUrl(ctx.projectId, ctx.task.key), {
+    card: ctx.task.card,
+    assumptions: ctx.task.assumptions || [],
+    found: ctx.task.found || [],
+    used: ctx.task.used || [],
+    plan: { ...withSnapshot(review, ctx.task.card, cwd), approach: proposed.approach, version, basis: null, submittedAt: new Date().toISOString() },
+  })
+  return { note: review.warnings.length ? `${review.warnings.length} plan warning(s): see tspl plan show ${ctx.task.key}` : null }
+}
+
+/** Sends one screenshot or video to the task, tied to its check, commit and test case. */
+const uploadArtifact = (projectId, key, file) =>
+  request('POST', `${taskUrl(projectId, key)}/artifacts`, {
+    name: file.name || require('path').basename(file.path),
+    contentType: file.contentType,
+    data: Fs.readFileSync(file.path).toString('base64'),
+    criterion: file.criterion || null,
+    checkId: file.checkId || null,
+    step: file.step ? String(file.step).slice(0, 500) : null,
+    headSha: file.headSha || null,
+    source: 'cli',
+  })
+
+const controllerDeps = (cwd, { interactive = Boolean(process.stdin.isTTY) } = {}) => ({
+  uploadArtifact,
+  load,
+  plan: ctx => plan(cwd, ctx, { interactive }),
+  client: (projectId, key) => workflowClient(projectId, key),
+  agents: { implementTask, reviewTask },
+  runChecks,
+  captureHeads,
+  engineFor,
+  ciWaitMs: 10 * 60 * 1000,
+  prepareBuild,
+  buildBlockers: blockers,
+  startBuild: runBuild,
+  refreshChecklist,
+  refreshTask: (projectId, key) => request('GET', taskUrl(projectId, key)),
+  git: gitOps,
+  providerFor: repoConfig => createProvider(repoConfig),
+  confirm: interactive ? message => confirm({ message: `${message}\nContinue?`, default: false }) : null,
+  chooseBranch: interactive ? proposal => askBranchChoice(proposal, { input, confirm, search }) : null,
+  claimCheckouts,
+  runs: { read: readRun, write: writeRun },
+  finishLocal,
+})
+
+const renderOutcome = result => {
+  const lines = [`Stage: ${result.stage}`]
+  result.blockers.forEach(line => lines.push(`  ! ${line}`))
+  ;(result.warnings || []).forEach(line => lines.push(`  ! ${line}`))
+  ;(result.prs || []).forEach(pr => lines.push(`  PR ${pr.repo}: ${pr.url} (${pr.draft ? 'draft' : pr.state})`))
+  if (result.next.length) lines.push('Next:', ...result.next.map(line => `  ${line}`))
+  return lines.join('\n')
+}
+
+module.exports = {
+  controllerDeps,
+  renderOutcome,
+  finishLocal,
+  taskUrl,
+  uploadArtifact,
+}

package/src/workflow/wait.js

@@ -0,0 +1,58 @@
+'use strict'
+
+/**
+ * Stages where the run stops for a person somewhere else (the console or another terminal): approving a plan,
+ * confirming scope, recording a manual check, or CI. Anything else needs the developer at this keyboard.
+ */
+const waitsForOthers = result => {
+  if (['awaiting-approval', 'awaiting-ci'].includes(result.stage)) return true
+  if (result.stage === 'reviewing') return true
+  if (result.stage === 'planning') return result.blockers.some(line => /has not confirmed the scope/.test(line))
+  return false
+}
+
+/** What a person can change while we wait; when any of it moves, the run is worth trying again. */
+const fingerprint = task => {
+  const workflow = task.workflow || {}
+  return JSON.stringify([
+    task.status,
+    task.scope ? task.scope.confirmed : null,
+    task.plan ? task.plan.version : null,
+    (task.decisions || []).length,
+    workflow.revision || 0,
+    (workflow.manualVerifications || []).length,
+    (workflow.prs || []).map(pr => [pr.headSha, (pr.checks || []).map(check => `${check.status}:${check.conclusion}`)]),
+  ])
+}
+
+const sleep = (ms, signal) =>
+  new Promise((resolve, reject) => {
+    if (signal && signal.aborted) return reject(signal.reason || new Error('aborted'))
+    const timer = setTimeout(resolve, ms)
+    if (signal) signal.addEventListener('abort', () => (clearTimeout(timer), reject(signal.reason || new Error('aborted'))), { once: true })
+  })
+
+/**
+ * Runs the task, and whenever it stops for someone else, checks the server every `intervalMs` and runs it again
+ * as soon as something changed. CI is rechecked on every tick because its state lives with the git host.
+ * Returns the last outcome: ready, or the first stop that needs the developer.
+ */
+const runUntilDone = async ({ run, fetchTask, report, log, signal, intervalMs = 15000, waitMs = sleep }) => {
+  for (;;) {
+    const result = await run()
+    report(result)
+    if (result.stage === 'ready' || !waitsForOthers(result)) return result
+    let seen = fingerprint(await fetchTask())
+    log(`Waiting for ${result.stage === 'awaiting-ci' ? 'CI' : 'a person'}; checking every ${Math.round(intervalMs / 1000)}s and continuing by itself. Ctrl+C stops waiting.`)
+    for (;;) {
+      await waitMs(intervalMs, signal)
+      if (result.stage === 'awaiting-ci') break
+      const now = fingerprint(await fetchTask())
+      if (now !== seen) break
+      seen = now
+    }
+    log('Something changed; continuing.')
+  }
+}
+
+module.exports = { runUntilDone, waitsForOthers, fingerprint }

package/src/workspace.js

@@ -0,0 +1,250 @@
+'use strict'
+
+const Fs = require('fs')
+const Path = require('path')
+const { checkbox, confirm, input, select } = require('@inquirer/prompts')
+
+const { request } = require('./api-client')
+const { readCredentials, readLinks, writeLinks } = require('./config-store')
+const { findRepos, defaultBranch, identify } = require('./git-helper')
+const { detectStacks } = require('./stack-detector')
+
+const scan = folder =>
+  findRepos(folder)
+    .map(dir => ({
+      dir,
+      name: Path.basename(dir),
+      branch: defaultBranch(dir),
+      stacks: detectStacks(dir),
+      ...identify(dir),
+    }))
+    .filter(repo => repo.fingerprint || repo.remoteHash)
+
+const sameRepo = (projectRepo, localRepo) =>
+  Boolean(
+    (projectRepo.fingerprint && projectRepo.fingerprint === localRepo.fingerprint) ||
+      (projectRepo.remoteHash && projectRepo.remoteHash === localRepo.remoteHash),
+  )
+
+const toPayload = repo => ({
+  name: repo.name,
+  fingerprint: repo.fingerprint,
+  remoteHash: repo.remoteHash,
+  defaultBaseBranch: repo.branch || undefined,
+})
+
+const linkKey = project => `${readCredentials().organization}/${project.slug}`
+
+const pickRepos = (message, repos, options) => {
+  if (options.yes) {
+    return repos
+  }
+  return checkbox({
+    message,
+    choices: repos.map(repo => ({ name: repo.name, value: repo, checked: true })),
+  })
+}
+
+const createProject = async (folder, local, options) => {
+  const suggested = options.name || Path.basename(folder)
+  if (!options.yes) {
+    const create = await confirm({
+      message: `These ${local.length} repos are not in any project yet. Create a project for them?`,
+      default: true,
+    })
+    if (!create) {
+      return {}
+    }
+  }
+
+  const name = options.yes
+    ? suggested
+    : await input({ message: 'Project name:', default: suggested })
+  const repos = await pickRepos('Include which repos?', local, options)
+
+  try {
+    const project = await request('POST', '/api/v1/projects', {
+      name,
+      repos: repos.map(toPayload),
+    })
+    return { project, excluded: local.filter(repo => !repos.includes(repo)) }
+  } catch (err) {
+    if (err.statusCode === 403) {
+      throw new Error(
+        'No project uses these repos yet. Ask an owner, admin or PM to create one.',
+      )
+    }
+    throw err
+  }
+}
+
+const NEW_PROJECT = '__new__'
+
+/** Offers the projects that already exist before a new one is created. null means: create a new project. */
+const pickExisting = async options => {
+  if (options.project) {
+    const found = await request('GET', `/api/v1/projects/${encodeURIComponent(options.project)}`)
+    return found
+  }
+  if (options.yes) return null
+  const projects = await request('GET', '/api/v1/projects')
+  if (!projects.length) return null
+  const picked = await select({
+    message: 'These repos are not in any project yet. Which project are they part of?',
+    choices: [
+      ...projects.map(project => ({ name: `${project.name} (${project.repos.length} repos)`, value: project })),
+      { name: 'None of these: create a new project', value: NEW_PROJECT },
+    ],
+  })
+  return picked === NEW_PROJECT ? null : picked
+}
+
+const chooseProject = async (matches, options) => {
+  if (matches.length === 1) {
+    return matches[0]
+  }
+  if (options.yes) {
+    throw new Error(
+      `These repos belong to several projects (${matches.map(p => p.slug).join(', ')}). Run without --yes to choose.`,
+    )
+  }
+  return select({
+    message: 'These repos belong to several projects. Which one are you working on?',
+    choices: matches.map(project => ({ name: project.name, value: project })),
+  })
+}
+
+const addMissingRepos = async (project, local, ignored, options) => {
+  const missing = local.filter(
+    repo =>
+      !project.repos.some(r => sameRepo(r, repo)) &&
+      !ignored.includes(repo.fingerprint || repo.remoteHash),
+  )
+  if (!missing.length) {
+    return { project, declined: [] }
+  }
+
+  const chosen = await pickRepos(
+    `These repos are in this folder but not in "${project.name}". Add which?`,
+    missing,
+    options,
+  )
+
+  let current = project
+  for (const repo of chosen) {
+    try {
+      current = await request(
+        'POST',
+        `/api/v1/projects/${current._id}/repos`,
+        toPayload(repo),
+      )
+    } catch (err) {
+      console.log(`Could not add ${repo.name}: ${err.message}`)
+    }
+  }
+
+  const declined = missing
+    .filter(repo => !chosen.includes(repo))
+    .map(repo => repo.fingerprint || repo.remoteHash)
+  return { project: current, declined }
+}
+
+const setupProject = async (folderArg, options = {}) => {
+  const folder = Path.resolve(folderArg || process.cwd())
+  const local = scan(folder)
+  if (!local.length) {
+    throw new Error(
+      `No git repos found in ${folder}. Run tspl inside a project folder or one of its repos.`,
+    )
+  }
+
+  const matches = await request('POST', '/api/v1/projects/match', {
+    fingerprints: local.map(r => r.fingerprint).filter(Boolean),
+    remoteHashes: local.map(r => r.remoteHash).filter(Boolean),
+  })
+
+  let project
+  let result
+  if (matches.length) {
+    project = await chooseProject(matches, options)
+  } else {
+    const existing = await pickExisting(options)
+    if (existing) {
+      project = existing
+    } else {
+      const created = await createProject(folder, local, options)
+      if (!created.project) {
+        return null
+      }
+      project = created.project
+      result = {
+        project,
+        declined: created.excluded.map(repo => repo.fingerprint || repo.remoteHash),
+      }
+    }
+  }
+
+  const links = readLinks()
+  const key = linkKey(project)
+  const previous = result ? {} : links[key] || {}
+  if (!result) {
+    result = await addMissingRepos(project, local, previous.ignored || [], options)
+  }
+  project = result.project
+
+  const repos = {}
+  const linked = []
+  project.repos.forEach(repo => {
+    const found = local.find(l => sameRepo(repo, l))
+    if (found) {
+      repos[repo._id] = { name: repo.name, path: found.dir }
+      linked.push({ ...repo, stacks: found.stacks, path: found.dir })
+    }
+  })
+
+  links[key] = {
+    projectId: project._id,
+    folder,
+    repos: { ...(previous.repos || {}), ...repos },
+    ignored: [...new Set([...(previous.ignored || []), ...result.declined])],
+  }
+  writeLinks(links)
+
+  return { project, folder, linked }
+}
+
+const localRepos = project => {
+  const known = (readLinks()[linkKey(project)] || {}).repos || {}
+  return project.repos
+    .filter(repo => known[repo._id] && Fs.existsSync(known[repo._id].path))
+    .map(repo => ({ ...repo, path: known[repo._id].path }))
+}
+
+const inside = (dir, parent) => Boolean(parent) && (dir === parent || dir.startsWith(`${parent}${Path.sep}`))
+
+const findProject = async folder => {
+  const dir = Path.resolve(folder)
+  const [key, link] =
+    Object.entries(readLinks()).find(
+      ([, entry]) =>
+        inside(dir, entry.folder) || Object.values(entry.repos || {}).some(repo => inside(dir, repo.path)),
+    ) || []
+  if (!key) {
+    throw new Error(`${dir} is not set up for tspl yet. Run tspl in a terminal in this folder first.`)
+  }
+  try {
+    const project = await request('GET', `/api/v1/projects/${encodeURIComponent(key.split('/').pop())}`)
+    return { project, repos: localRepos(project), offline: false }
+  } catch (err) {
+    if (err.statusCode === 0 && link.projectId) {
+      return { project: { _id: link.projectId, name: key.split('/').pop() }, repos: [], offline: true }
+    }
+    throw err
+  }
+}
+
+module.exports = {
+  setupProject,
+  localRepos,
+  findProject,
+}