@panagos/jojoscript 0.9.3 → 1.0.0

package/bin/jojo.js

@@ -5,8 +5,16 @@ import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { spawn, spawnSync } from 'node:child_process'
 
-import { compile, compileFile, compileDirectory } from '../src/compiler.js'
+import { compile, compileFile, compileDirectory, findJojoFiles } from '../src/compiler.js'
+import { formatSource } from '../src/formatter.js'
+import { parseSource } from '../src/parse.js'
 import { analyzePipelines, renderGraphText, renderGraphDot } from '../src/pipeline-ir.js'
+import { explainPipelines, renderExplanationText } from '../src/pipeline-explain.js'
+import { planPipelines, planToJojo } from '../src/pipeline-plan.js'
+import { checkSource, checkPlan, renderCheckText } from '../src/check.js'
+import { describeSource } from '../src/describe.js'
+import { simulatePipelines, renderSimulationText } from '../src/simulate.js'
+import { whyPipelines, renderWhyText } from '../src/why.js'
 import { FileCheckpointStore } from '../src/runtime/checkpoint-store.js'
 
 const PACKAGE_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..')
@@ -22,8 +30,17 @@ function usage() {
 
 Usage:
   jojo build <file.jojo|directory> [--out <directory>] [--watch]
-  jojo run <file.jojo> [--out <directory>]
-  jojo graph <file.jojo> [--format text|dot]
+  jojo run <file.jojo> [--out <directory>] [--deterministic [--seed <n>]]
+  jojo graph <file.jojo> [--format text|dot] [--pipeline <name>]
+  jojo explain <file.jojo> [--format text|json] [--pipeline <name>]
+  jojo plan <file.jojo> [--format json] [--pipeline <name>]
+  jojo generate <plan.json>
+  jojo check <file.jojo|plan.json> [--format text|json] [--machine]
+  jojo describe <file.jojo> [--pipeline <name>]
+  jojo simulate <file.jojo> [--input <records>] [--format text|json] [--pipeline <name>]
+  jojo why <file.jojo> [--format text|json] [--pipeline <name>]
+  jojo format <file.jojo|directory> [--check]
+  jojo parse <file.jojo> [--json]
   jojo profile <file.jojo>
   jojo resume <file.jojo> [--out <directory>]
   jojo replay <file.jojo> --from <checkpoint> [--out <directory>]
@@ -37,8 +54,18 @@ Examples:
   jojo build src --out dist
   jojo build src --watch
   jojo run src/main.jojo
+  jojo run src/main.jojo --deterministic --seed 42
   jojo graph orders.jojo
   jojo graph orders.jojo --format dot
+  jojo explain orders.jojo --format json
+  jojo plan orders.jojo --format=json
+  jojo generate orders.plan.json
+  jojo check generated.jojo --machine
+  jojo describe orders.jojo
+  jojo simulate orders.jojo --input 1000000
+  jojo why orders.jojo --pipeline enrichOrders
+  jojo format src --check
+  jojo parse program.jojo --json
   jojo profile orders.jojo
   jojo resume orders.jojo
   jojo replay orders.jojo --from enriched
@@ -114,14 +141,27 @@ function watch(input, out) {
 
   rebuild()
 
-  fs.watch(resolvedInput, { recursive: true }, (_, filename) => {
+  const watcher = fs.watch(resolvedInput, { recursive: true }, (_, filename) => {
     if (filename && !filename.endsWith('.jojo')) return
     console.log(`\nChange detected${filename ? `: ${filename}` : ''}, rebuilding...`)
     rebuild()
   })
+
+  const stop = () => {
+    watcher.close()
+    process.exit(0)
+  }
+  process.once('SIGINT', stop)
+  process.once('SIGTERM', stop)
+}
+
+// The whole program, including top-level code, is imported inside the deterministic scope.
+function deterministicBootstrap(output, seed) {
+  return `import { deterministic } from ${JSON.stringify(RUNTIME_IMPORT)}\n` +
+    `await deterministic(() => import(${JSON.stringify(pathToFileURL(output).href)}), { seed: ${seed} })\n`
 }
 
-function run(input, out) {
+function run(input, out, seed = null) {
   const resolvedInput = path.resolve(input)
 
   if (!fs.existsSync(resolvedInput) || fs.statSync(resolvedInput).isDirectory()) {
@@ -130,7 +170,8 @@ function run(input, out) {
 
   const [{ output }] = build(input, out)
 
-  const child = spawn(process.execPath, [output], { stdio: 'inherit' })
+  const args = seed === null ? [output] : ['--input-type=module', '--eval', deterministicBootstrap(output, seed)]
+  const child = spawn(process.execPath, args, { stdio: 'inherit' })
   child.on('exit', code => process.exit(code ?? 0))
   child.on('error', error => fail(error.message))
 }
@@ -146,10 +187,18 @@ function requireSingleFile(command, input) {
   return resolvedInput
 }
 
-function graph(input, format) {
+function selectPipelines(items, names, wanted) {
+  if (!wanted) return items
+  const selected = items.filter((_, index) => names[index] === wanted)
+  if (!selected.length) fail(`No pipeline named "${wanted}"`)
+  return selected
+}
+
+function graph(input, format, wanted) {
   const resolvedInput = requireSingleFile('graph', input)
   const source = fs.readFileSync(resolvedInput, 'utf8')
-  const pipelines = analyzePipelines(source)
+  const names = explainPipelines(source).map(explanation => explanation.name)
+  const pipelines = selectPipelines(analyzePipelines(source), names, wanted)
 
   if (!pipelines.length) {
     console.log('No pipelines found.')
@@ -162,6 +211,119 @@ function graph(input, format) {
   })
 }
 
+function explain(input, format, wanted) {
+  const resolvedInput = requireSingleFile('explain', input)
+  const all = explainPipelines(fs.readFileSync(resolvedInput, 'utf8'))
+  const explanations = selectPipelines(all, all.map(explanation => explanation.name), wanted)
+
+  if (format === 'json') {
+    console.log(JSON.stringify(explanations, null, 2))
+    return
+  }
+
+  if (!explanations.length) {
+    console.log('No pipelines found.')
+    return
+  }
+
+  console.log(explanations.map(renderExplanationText).join('\n\n'))
+}
+
+function plan(input, wanted) {
+  const resolvedInput = requireSingleFile('plan', input)
+  const fullPlan = planPipelines(fs.readFileSync(resolvedInput, 'utf8'))
+  const pipelines = selectPipelines(fullPlan.pipelines, fullPlan.pipelines.map(item => item.pipeline), wanted)
+  console.log(JSON.stringify({ ...fullPlan, pipelines }, null, 2))
+}
+
+function readPlan(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch (error) {
+    fail(`Invalid plan JSON: ${error.message}`)
+  }
+}
+
+function generate(input) {
+  const resolvedInput = requireSingleFile('generate', input)
+  process.stdout.write(planToJojo(readPlan(resolvedInput)))
+}
+
+function describe(input, wanted) {
+  const resolvedInput = requireSingleFile('describe', input)
+  const description = describeSource(fs.readFileSync(resolvedInput, 'utf8'))
+  const pipelines = selectPipelines(description.pipelines, description.pipelines.map(item => item.name), wanted)
+  console.log(JSON.stringify({ ...description, pipelines }, null, 2))
+}
+
+function takeOption(args, name) {
+  const index = args.findIndex(arg => arg === name || arg.startsWith(`${name}=`))
+  if (index === -1) return { value: null, rest: args }
+
+  const inline = args[index] !== name
+  const value = inline ? args[index].slice(name.length + 1) : args[index + 1]
+  return { value, rest: args.filter((_, i) => i !== index && (inline || i !== index + 1)) }
+}
+
+function simulate(input, { format, pipeline, records }) {
+  const resolvedInput = requireSingleFile('simulate', input)
+  const all = simulatePipelines(fs.readFileSync(resolvedInput, 'utf8'), { input: records ?? undefined })
+  const simulations = selectPipelines(all, all.map(simulation => simulation.name), pipeline)
+
+  if (format === 'json') {
+    console.log(JSON.stringify(simulations, null, 2))
+    return
+  }
+
+  console.log(simulations.length ? simulations.map(renderSimulationText).join('\n\n') : 'No pipelines found.')
+}
+
+function parse(input) {
+  const resolvedInput = requireSingleFile('parse', input)
+  console.log(JSON.stringify(parseSource(fs.readFileSync(resolvedInput, 'utf8')), null, 2))
+}
+
+function formatFiles(input, checkOnly) {
+  const resolvedInput = path.resolve(input)
+  if (!fs.existsSync(resolvedInput)) fail(`Not found: ${resolvedInput}`)
+
+  const files = fs.statSync(resolvedInput).isDirectory() ? findJojoFiles(resolvedInput) : [resolvedInput]
+  const changed = files.filter(file => {
+    const source = fs.readFileSync(file, 'utf8')
+    const formatted = formatSource(source)
+    if (formatted === source) return false
+    if (!checkOnly) fs.writeFileSync(file, formatted, 'utf8')
+    return true
+  })
+
+  if (checkOnly && !changed.length) console.log('All files are formatted.')
+  for (const file of changed) console.log(checkOnly ? `Needs formatting: ${file}` : `Formatted ${file}`)
+  if (checkOnly && changed.length) process.exitCode = 1
+}
+
+function why(input, format, wanted) {
+  const resolvedInput = requireSingleFile('why', input)
+  const all = whyPipelines(fs.readFileSync(resolvedInput, 'utf8'))
+  const answers = selectPipelines(all, all.map(item => item.name), wanted)
+
+  if (format === 'json') {
+    console.log(JSON.stringify(answers, null, 2))
+    return
+  }
+
+  console.log(answers.length ? answers.map(renderWhyText).join('\n\n') : 'No pipelines found.')
+}
+
+function check(input, format) {
+  const resolvedInput = requireSingleFile('check', input)
+  const result = resolvedInput.endsWith('.json')
+    ? checkPlan(readPlan(resolvedInput))
+    : checkSource(fs.readFileSync(resolvedInput, 'utf8'))
+
+  console.log(format === 'json' ? JSON.stringify(result, null, 2) : renderCheckText(result))
+  if (!result.valid) process.exitCode = 1
+}
+
 function profile(input) {
   const resolvedInput = requireSingleFile('profile', input)
   const source = fs.readFileSync(resolvedInput, 'utf8')
@@ -272,15 +434,22 @@ function replay(input, out, from) {
   run(input, out)
 }
 
-function parseGraphFlags(args, startIndex) {
-  let format = 'text'
+function parseFormatFlags(args, startIndex, formats) {
+  let format = formats[0]
+  let pipeline = null
 
   for (let i = startIndex; i < args.length; i++) {
     const arg = args[i]
 
-    if (arg === '--format') {
-      const value = args[++i]
-      if (value !== 'text' && value !== 'dot') fail('--format must be "text" or "dot"')
+    if (arg === '--pipeline' || arg.startsWith('--pipeline=')) {
+      pipeline = arg === '--pipeline' ? args[++i] : arg.slice('--pipeline='.length)
+      if (!pipeline) fail('--pipeline requires a pipeline name')
+      continue
+    }
+
+    if (arg === '--format' || arg.startsWith('--format=')) {
+      const value = arg === '--format' ? args[++i] : arg.slice('--format='.length)
+      if (!formats.includes(value)) fail(`--format must be ${formats.map(name => `"${name}"`).join(' or ')}`)
       format = value
       continue
     }
@@ -288,7 +457,7 @@ function parseGraphFlags(args, startIndex) {
     fail(`Unknown option: ${arg}`)
   }
 
-  return { format }
+  return { format, pipeline }
 }
 
 function parseReplayFlags(args, startIndex) {
@@ -350,7 +519,7 @@ function testCmd(input) {
   process.exit(result.status ?? 0)
 }
 
-const COMMANDS = new Set(['build', 'run', 'graph', 'profile', 'resume', 'replay', 'test'])
+const COMMANDS = new Set(['build', 'run', 'graph', 'explain', 'plan', 'generate', 'check', 'describe', 'simulate', 'why', 'format', 'parse', 'profile', 'resume', 'replay', 'test'])
 
 function main() {
   const args = process.argv.slice(2)
@@ -379,8 +548,67 @@ function main() {
   const input = args[1]
 
   if (command === 'graph') {
-    const { format } = parseGraphFlags(args, 2)
-    graph(input, format)
+    const { format, pipeline } = parseFormatFlags(args, 2, ['text', 'dot'])
+    graph(input, format, pipeline)
+    return
+  }
+
+  if (command === 'plan') {
+    const { pipeline } = parseFormatFlags(args, 2, ['json'])
+    plan(input, pipeline)
+    return
+  }
+
+  if (command === 'parse') {
+    parseFormatFlags(args.filter(arg => arg !== '--json'), 2, ['json'])
+    parse(input)
+    return
+  }
+
+  if (command === 'format') {
+    const checkOnly = args.includes('--check')
+    const unknown = args.slice(2).find(arg => arg !== '--check')
+    if (unknown) fail(`Unknown option: ${unknown}`)
+    formatFiles(input, checkOnly)
+    return
+  }
+
+  if (command === 'why') {
+    const { format, pipeline } = parseFormatFlags(args, 2, ['text', 'json'])
+    why(input, format, pipeline)
+    return
+  }
+
+  if (command === 'simulate') {
+    const { value, rest } = takeOption(args, '--input')
+    if (value !== null && !/^[1-9]\d*$/.test(value ?? '')) fail('--input must be a positive integer')
+    const { format, pipeline } = parseFormatFlags(rest, 2, ['text', 'json'])
+    simulate(input, { format, pipeline, records: value === null ? null : Number(value) })
+    return
+  }
+
+  if (command === 'describe') {
+    const { pipeline } = parseFormatFlags(args, 2, ['json'])
+    describe(input, pipeline)
+    return
+  }
+
+  if (command === 'check') {
+    const machine = args.includes('--machine')
+    const { format } = parseFormatFlags(args.filter(arg => arg !== '--machine'), 2, ['text', 'json'])
+    check(input, machine ? 'json' : format)
+    return
+  }
+
+  if (command === 'generate') {
+    if (args[2]) fail(`Unknown option: ${args[2]}`)
+    generate(input)
+    return
+  }
+
+  if (command === 'explain') {
+    const { format, pipeline } = parseFormatFlags(args, 2, ['text', 'json'])
+    explain(input, format, pipeline)
     return
   }
 
@@ -400,6 +628,18 @@ function main() {
     return
   }
 
+  if (command === 'run') {
+    const { value: seed, rest } = takeOption(args.filter(arg => arg !== '--deterministic'), '--seed')
+    const isDeterministic = args.includes('--deterministic')
+    if (seed !== null && !isDeterministic) fail('--seed requires --deterministic')
+    if (seed !== null && !/^\d+$/.test(seed ?? '')) fail('--seed must be a non-negative integer')
+
+    const { out, watch: shouldWatch } = parseFlags(rest, 2)
+    if (shouldWatch) fail('--watch is not supported with `jojo run`, use `jojo build --watch` instead')
+    run(input, out, isDeterministic ? Number(seed ?? 1) : null)
+    return
+  }
+
   const { out, watch: shouldWatch } = parseFlags(args, 2)
 
   if (command === 'resume') {
@@ -408,12 +648,6 @@ function main() {
     return
   }
 
-  if (command === 'run') {
-    if (shouldWatch) fail('--watch is not supported with `jojo run`, use `jojo build --watch` instead')
-    run(input, out)
-    return
-  }
-
   if (shouldWatch) {
     watch(input, out)
     return

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@panagos/jojoscript",
-  "version": "0.9.3",
-  "description": "A tiny JavaScript-compatible language layer with Jojo syntax and pipelines.",
+  "version": "1.0.0",
+  "description": "JojoScript is a lightweight language and runtime for data pipelines and agent workflows, built on JavaScript.",
   "license": "Unlicense",
   "type": "module",
   "bin": {

package/src/check.js

@@ -0,0 +1,253 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+import { compile } from './compiler.js'
+import { maskNonCode, tokenize } from './lexer.js'
+import { findEffectDeclarations, findHandleBlocks } from './effect-parser.js'
+import { findPurityViolations } from './purity.js'
+import { findContracts } from './contracts.js'
+import { findTypeDeclarations } from './type-declarations.js'
+import { findMatchExpressions } from './match-parser.js'
+import { planToJojo } from './pipeline-plan.js'
+
+const LITERAL_KEYWORDS = { true: true, false: false, null: null, undefined }
+const CONDITION_KEYWORDS = new Set(['typeof', ...Object.keys(LITERAL_KEYWORDS)])
+
+function diagnostic(code, line, message, suggestion) {
+  return { code, severity: code.startsWith('W') ? 'warning' : 'error', line, message, suggestion }
+}
+
+function lineAt(source, offset) {
+  return source.slice(0, offset).split('\n').length
+}
+
+function nameUsage(name) {
+  return new RegExp(`(?<![.\\w$])${name}(?![\\w$])`, 'g')
+}
+
+// Static analyses skip code they cannot parse; the compiler then reports it as E100.
+function analyze(fn) {
+  try {
+    return fn()
+  } catch {
+    return []
+  }
+}
+
+function missingHandlers(source) {
+  const code = maskNonCode(source)
+  const handled = new Set(findHandleBlocks(source).flatMap(block => block.handlerNames))
+
+  return findEffectDeclarations(source)
+    .filter(effect => !handled.has(effect.name))
+    .flatMap(effect => {
+      const use = [...code.matchAll(nameUsage(effect.name))]
+        .find(match => match.index < effect.start || match.index >= effect.end)
+      if (!use) return []
+
+      return [diagnostic(
+        'W102',
+        lineAt(source, use.index),
+        `Effect "${effect.name}" has no handler in this file`,
+        `Add a handler for "${effect.name}" in a handle { ... } block, or make sure every caller installs one`
+      )]
+    })
+}
+
+function purityErrors(source) {
+  return findPurityViolations(source).map(violation => diagnostic(
+    'E201',
+    violation.line,
+    `pure fn "${violation.function}" uses ${violation.kind} "${violation.uses}"`,
+    `Remove the use of "${violation.uses}" from "${violation.function}", or declare "${violation.function}" as effectful fn`
+  ))
+}
+
+function literalValue(text) {
+  if (/^-?\d+(\.\d+)?$/.test(text)) return { value: Number(text) }
+  const string = text.match(/^(["'])([^"'\\]*)\1$/)
+  if (string) return { value: string[2] }
+  if (Object.hasOwn(LITERAL_KEYWORDS, text)) return { value: LITERAL_KEYWORDS[text] }
+  return null
+}
+
+function splitArguments(text) {
+  const result = []
+  let depth = 0
+  let start = 0
+  for (let i = 0; i < text.length; i++) {
+    if ('([{'.includes(text[i])) depth++
+    else if (')]}'.includes(text[i])) depth--
+    else if (text[i] === ',' && depth === 0) {
+      result.push(text.slice(start, i).trim())
+      start = i + 1
+    }
+  }
+  if (text.trim()) result.push(text.slice(start).trim())
+  return result
+}
+
+/*
+ * A condition is evaluated only when it is built from parameters, literals,
+ * and operators: no property access, indexing, calls, or other names, so
+ * checking never runs user code.
+ */
+function evaluableCondition(condition, params) {
+  const tokens = tokenize(condition)
+  return tokens.every((token, index) => {
+    if (token.type === 'identifier') return params.includes(token.value) || CONDITION_KEYWORDS.has(token.value)
+    if (['.', '[', '?.', '=>'].includes(token.value)) return false
+    return !(token.value === '(' && tokens[index - 1]?.type === 'identifier')
+  })
+}
+
+function contractViolations(source) {
+  const code = maskNonCode(source)
+
+  return findContracts(source).flatMap(contract => [...code.matchAll(new RegExp(`(?<![.\\w$])${contract.name}\\s*\\(`, 'g'))]
+    .filter(call => !/\bfn\s+$/.test(code.slice(Math.max(0, call.index - 10), call.index)))
+    .flatMap(call => {
+      const open = call.index + call[0].length - 1
+      let depth = 0
+      let close = open
+      for (; close < code.length; close++) {
+        if (code[close] === '(') depth++
+        else if (code[close] === ')' && --depth === 0) break
+      }
+
+      const literals = splitArguments(source.slice(open + 1, close)).map(literalValue)
+      if (literals.length !== contract.params.length || literals.some(literal => !literal)) return []
+
+      const values = literals.map(literal => literal.value)
+      const broken = contract.requires.find(({ condition }) =>
+        evaluableCondition(condition, contract.params) &&
+        !new Function(...contract.params, `return (${condition})`)(...values))
+      if (!broken) return []
+
+      return [diagnostic(
+        'E301',
+        lineAt(source, call.index),
+        `Call ${source.slice(call.index, close + 1)} violates "requires ${broken.condition}"`,
+        `Pass arguments to "${contract.name}" that satisfy ${broken.condition}`
+      )]
+    }))
+}
+
+function matchErrors(source) {
+  const variants = new Map()
+  for (const type of findTypeDeclarations(source)) {
+    for (const variant of type.variants) variants.set(variant.name, { ...variant, type })
+  }
+
+  return findMatchExpressions(source).flatMap(match => {
+    const known = match.arms.map(arm => arm.variant).filter(variant => variant && variants.has(variant.name))
+    if (!known.length) return []
+
+    const arity = known
+      .filter(variant => variant.arity !== variants.get(variant.name).fields.length)
+      .map(variant => {
+        const declared = variants.get(variant.name)
+        return diagnostic(
+          'E402',
+          variant.line,
+          `Pattern ${variant.name}(...) has ${variant.arity} fields, but variant ${variant.name} declares ${declared.fields.length} (${declared.fields.join(', ')})`,
+          `Match ${variant.name} with exactly ${declared.fields.length} field pattern(s)`
+        )
+      })
+
+    const types = new Set(known.map(variant => variants.get(variant.name).type))
+    if (match.hasDefault || types.size !== 1) return arity
+
+    const [type] = types
+    const covered = new Set(known.map(variant => variant.name))
+    const missing = type.variants
+      .filter(variant => !covered.has(variant.name))
+      .map(variant => diagnostic(
+        'E401',
+        match.line,
+        `match on ${type.name} does not handle variant ${variant.name}`,
+        `Add a "${variant.name}(...) => ..." arm or a final "_ => ..." arm`
+      ))
+
+    return [...missing, ...arity]
+  })
+}
+
+function javascriptError(compiled) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jojo-check-'))
+  const file = path.join(dir, 'program.mjs')
+
+  try {
+    fs.writeFileSync(file, compiled)
+    const result = spawnSync(process.execPath, ['--check', file], { encoding: 'utf8' })
+    if (result.status === 0) return null
+    const message = result.stderr.split('\n').find(line => /^\w*Error: /.test(line)) ?? result.stderr.trim()
+    return diagnostic('E101', null, `Compiled JavaScript is invalid: ${message}`, 'Fix the JavaScript syntax near the reported construct and run jojo check again')
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+}
+
+function compilerDiagnostics(source, reported) {
+  let compiled
+  try {
+    compiled = compile(source)
+  } catch (error) {
+    if (error.message.startsWith('pure fn ') && reported.some(item => item.code === 'E201')) return []
+    const line = error.message.match(/\(line (\d+)\)/)?.[1]
+    return [diagnostic('E100', line ? Number(line) : null, error.message, 'Fix the reported syntax and run jojo check again')]
+  }
+
+  const invalid = javascriptError(compiled)
+  return invalid ? [invalid] : []
+}
+
+function byLine(a, b) {
+  return (a.line ?? Infinity) - (b.line ?? Infinity)
+}
+
+function result(diagnostics) {
+  const errors = diagnostics.filter(item => item.severity === 'error').sort(byLine)
+  const warnings = diagnostics.filter(item => item.severity === 'warning').sort(byLine)
+  return { valid: errors.length === 0, errors, warnings }
+}
+
+export function checkSource(source) {
+  const diagnostics = [
+    ...analyze(() => missingHandlers(source)),
+    ...analyze(() => purityErrors(source)),
+    ...analyze(() => contractViolations(source)),
+    ...analyze(() => matchErrors(source))
+  ]
+
+  return result([...diagnostics, ...compilerDiagnostics(source, diagnostics)])
+}
+
+export function checkPlan(plan) {
+  try {
+    planToJojo(plan)
+    return result([])
+  } catch (error) {
+    if (error.name !== 'PlanValidationError') throw error
+    return result([diagnostic('E700', null, error.message, 'Fix the plan field named in the message and run jojo check again')])
+  }
+}
+
+function plural(count, word) {
+  return `${count} ${word}${count === 1 ? '' : 's'}`
+}
+
+export function renderCheckText({ errors, warnings }) {
+  if (!errors.length && !warnings.length) return 'valid: no problems found'
+
+  const blocks = [...errors, ...warnings].map(item => [
+    `${item.severity.toUpperCase()} ${item.code}`,
+    ...(item.line === null ? [] : [`line ${item.line}`]),
+    item.message,
+    `suggestion: ${item.suggestion}`
+  ].join('\n'))
+
+  return [...blocks, `${plural(errors.length, 'error')}, ${plural(warnings.length, 'warning')}`].join('\n\n')
+}