opencastle 0.31.7 → 0.32.0

package/src/cli/convoy/contracts.test.ts

@@ -0,0 +1,279 @@
+import { describe, it, expect } from 'vitest'
+import {
+  AGENT_CONTRACTS,
+  validateOutput,
+  buildContractInstruction,
+  buildContractRetryPrompt,
+} from './contracts.js'
+
+// ── Registry well-formedness ──────────────────────────────────────────────────
+
+describe('AGENT_CONTRACTS registry', () => {
+  it('has entries for all expected agents', () => {
+    const expectedAgents = [
+      'developer', 'ui-ux-expert', 'testing-expert', 'security-expert',
+      'architect', 'researcher', 'reviewer', 'documentation-writer',
+      'copywriter', 'performance-expert', 'database-engineer', 'devops-expert',
+      'api-designer', 'data-expert', 'seo-specialist', 'release-manager',
+    ]
+    for (const agent of expectedAgents) {
+      expect(AGENT_CONTRACTS).toHaveProperty(agent)
+    }
+  })
+
+  it('every contract has non-empty required_fields', () => {
+    for (const [key, contract] of Object.entries(AGENT_CONTRACTS)) {
+      expect(contract.required_fields.length, `${key} should have required_fields`).toBeGreaterThan(0)
+    }
+  })
+
+  it('every required field has a schema entry', () => {
+    for (const [key, contract] of Object.entries(AGENT_CONTRACTS)) {
+      for (const field of contract.required_fields) {
+        expect(contract.schema, `${key}.${field} missing schema entry`).toHaveProperty(field)
+      }
+    }
+  })
+
+  it('every schema entry has a valid type', () => {
+    const validTypes = new Set(['string', 'string[]', 'number', 'boolean', 'object'])
+    for (const [key, contract] of Object.entries(AGENT_CONTRACTS)) {
+      for (const [field, spec] of Object.entries(contract.schema)) {
+        expect(validTypes.has(spec.type), `${key}.${field} has invalid type "${spec.type}"`).toBe(true)
+      }
+    }
+  })
+
+  it('every schema entry has a description', () => {
+    for (const [key, contract] of Object.entries(AGENT_CONTRACTS)) {
+      for (const [field, spec] of Object.entries(contract.schema)) {
+        expect(spec.description, `${key}.${field} missing description`).toBeTruthy()
+      }
+    }
+  })
+
+  it('all optional_fields arrays are empty', () => {
+    for (const [key, contract] of Object.entries(AGENT_CONTRACTS)) {
+      expect(contract.optional_fields, `${key} should have empty optional_fields`).toHaveLength(0)
+    }
+  })
+})
+
+// ── validateOutput ────────────────────────────────────────────────────────────
+
+describe('validateOutput', () => {
+  it('returns valid for a complete developer contract block', () => {
+    const output = `
+Some work done here.
+
+<!-- OUTPUT_CONTRACT
+{ "files_changed": ["src/foo.ts"], "tests_added": ["src/foo.test.ts"], "summary": "Added foo feature" }
+-->
+`
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(true)
+    expect(result.missing).toHaveLength(0)
+    expect(result.warnings).toHaveLength(0)
+    expect(result.data).toBeDefined()
+  })
+
+  it('returns valid=false with missing __contract_block when no block present', () => {
+    const result = validateOutput('developer', 'No contract block here.')
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('__contract_block')
+    expect(result.warnings).toHaveLength(0)
+  })
+
+  it('returns valid=false with invalid_json warning when JSON is malformed', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ invalid json }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('__contract_block')
+    expect(result.warnings).toContain('invalid_json')
+  })
+
+  it('lists missing required fields', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": ["src/foo.ts"] }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('tests_added')
+    expect(result.missing).toContain('summary')
+    expect(result.missing).not.toContain('files_changed')
+  })
+
+  it('returns valid=true with no_contract_defined warning for unknown agent', () => {
+    const result = validateOutput('unknown-agent-xyz', 'any output')
+    expect(result.valid).toBe(true)
+    expect(result.missing).toHaveLength(0)
+    expect(result.warnings).toContain('no_contract_defined')
+  })
+
+  it('is case-insensitive for agent name lookup', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": ["src/foo.ts"], "tests_added": [], "summary": "done" }\n-->'
+    const result = validateOutput('Developer', output)
+    expect(result.valid).toBe(true)
+  })
+
+  it('works for all registered agents with minimal valid data', () => {
+    const minimalData: Record<string, Record<string, unknown>> = {
+      'developer': { files_changed: ['src/foo.ts'], tests_added: ['src/foo.test.ts'], summary: 'done' },
+      'ui-ux-expert': { files_changed: ['src/btn.tsx'], components_created: ['src/btn.tsx'], a11y_verified: true, summary: 'done' },
+      'testing-expert': { test_files: ['src/foo.test.ts'], coverage_summary: '95%', summary: 'done' },
+      'security-expert': { findings: [], severity: 'none', files_reviewed: ['src/auth.ts'], summary: 'done' },
+      'architect': { decision: 'use microservices', alternatives_considered: 'monolith', risks: 'complexity', summary: 'done' },
+      'researcher': { findings: 'found stuff', sources: ['https://example.com'], confidence: 'high', summary: 'done' },
+      'reviewer': { verdict: 'pass', issues: [], summary: 'done' },
+      'documentation-writer': { files_changed: ['docs/readme.md'], summary: 'done' },
+      'copywriter': { content: 'some content', word_count: 50, summary: 'done' },
+      'performance-expert': { metrics_before: {}, metrics_after: {}, files_changed: [], summary: 'done' },
+      'database-engineer': { migrations: [], rls_policies: [], rollback_plan: 'delete rows', summary: 'done' },
+      'devops-expert': { files_changed: [], env_vars_added: [], summary: 'done' },
+      'api-designer': { endpoints: ['/api/v1/resource'], schemas: ['ResourceSchema'], summary: 'done' },
+      'data-expert': { pipeline_steps: ['extract', 'transform'], files_changed: [], summary: 'done' },
+      'seo-specialist': { files_changed: [], tags_added: ['og:title'], summary: 'done' },
+      'release-manager': { version: '1.0.0', changelog_entries: ['feat: new thing'], checks_passed: true, summary: 'done' },
+    }
+    for (const [agent, data] of Object.entries(minimalData)) {
+      const output = `<!-- OUTPUT_CONTRACT\n${JSON.stringify(data)}\n-->`
+      const result = validateOutput(agent, output)
+      expect(result.valid, `${agent} should be valid with minimal data`).toBe(true)
+    }
+  })
+})
+
+// ── Validation rules ──────────────────────────────────────────────────────────
+
+describe('validateOutput validation rules', () => {
+  it('non-empty rejects empty string for summary', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": ["src/foo.ts"], "tests_added": [], "summary": "" }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('summary')
+  })
+
+  it('non-empty rejects whitespace-only string for summary', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": ["src/foo.ts"], "tests_added": [], "summary": "   " }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('summary')
+  })
+
+  it('file-paths rejects non-array for files_changed', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": "src/foo.ts", "tests_added": [], "summary": "done" }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('files_changed')
+  })
+
+  it('file-paths rejects array with non-string values', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": [1, 2], "tests_added": [], "summary": "done" }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('files_changed')
+  })
+
+  it('file-paths accepts empty array', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "files_changed": [], "tests_added": [], "summary": "done" }\n-->'
+    const result = validateOutput('developer', output)
+    expect(result.valid).toBe(true)
+  })
+
+  it('positive-int rejects zero for word_count', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "content": "text", "word_count": 0, "summary": "done" }\n-->'
+    const result = validateOutput('copywriter', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('word_count')
+  })
+
+  it('positive-int rejects negative number for word_count', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "content": "text", "word_count": -5, "summary": "done" }\n-->'
+    const result = validateOutput('copywriter', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('word_count')
+  })
+
+  it('positive-int rejects non-number for word_count', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "content": "text", "word_count": "fifty", "summary": "done" }\n-->'
+    const result = validateOutput('copywriter', output)
+    expect(result.valid).toBe(false)
+    expect(result.missing).toContain('word_count')
+  })
+
+  it('positive-int accepts valid positive number for word_count', () => {
+    const output = '<!-- OUTPUT_CONTRACT\n{ "content": "text", "word_count": 100, "summary": "done" }\n-->'
+    const result = validateOutput('copywriter', output)
+    expect(result.valid).toBe(true)
+  })
+})
+
+// ── buildContractInstruction ──────────────────────────────────────────────────
+
+describe('buildContractInstruction', () => {
+  it('returns instruction string for known agents', () => {
+    const instruction = buildContractInstruction('developer')
+    expect(instruction).not.toBeNull()
+    expect(instruction).toContain('OUTPUT_CONTRACT')
+    expect(instruction).toContain('files_changed')
+    expect(instruction).toContain('tests_added')
+    expect(instruction).toContain('summary')
+    expect(instruction).toContain('REQUIRED')
+  })
+
+  it('returns null for unknown agents', () => {
+    const instruction = buildContractInstruction('unknown-agent-xyz')
+    expect(instruction).toBeNull()
+  })
+
+  it('is case-insensitive for agent lookup', () => {
+    const instruction = buildContractInstruction('Developer')
+    expect(instruction).not.toBeNull()
+  })
+
+  it('includes all required fields in the REQUIRED list', () => {
+    for (const [agent, contract] of Object.entries(AGENT_CONTRACTS)) {
+      const instruction = buildContractInstruction(agent)
+      expect(instruction).not.toBeNull()
+      for (const field of contract.required_fields) {
+        expect(instruction).toContain(field)
+      }
+    }
+  })
+
+  it('includes comment block markers', () => {
+    const instruction = buildContractInstruction('developer')
+    expect(instruction).toContain('<!-- OUTPUT_CONTRACT')
+    expect(instruction).toContain('-->')
+  })
+})
+
+// ── buildContractRetryPrompt ──────────────────────────────────────────────────
+
+describe('buildContractRetryPrompt', () => {
+  it('includes missing field names in the prompt', () => {
+    const result = { valid: false, missing: ['files_changed', 'summary'], warnings: [] }
+    const prompt = buildContractRetryPrompt(result)
+    expect(prompt).toContain('files_changed')
+    expect(prompt).toContain('summary')
+  })
+
+  it('includes OUTPUT_CONTRACT block template', () => {
+    const result = { valid: false, missing: ['__contract_block'], warnings: [] }
+    const prompt = buildContractRetryPrompt(result)
+    expect(prompt).toContain('OUTPUT_CONTRACT')
+    expect(prompt).toContain('-->')
+  })
+
+  it('mentions that the previous output was missing the block', () => {
+    const result = { valid: false, missing: ['__contract_block'], warnings: [] }
+    const prompt = buildContractRetryPrompt(result)
+    expect(prompt.toLowerCase()).toContain('missing')
+  })
+
+  it('handles multiple missing fields', () => {
+    const result = { valid: false, missing: ['field_a', 'field_b', 'field_c'], warnings: [] }
+    const prompt = buildContractRetryPrompt(result)
+    expect(prompt).toContain('field_a')
+    expect(prompt).toContain('field_b')
+    expect(prompt).toContain('field_c')
+  })
+})

package/src/cli/convoy/contracts.ts

@@ -0,0 +1,280 @@
+export interface FieldSpec {
+  type: 'string' | 'string[]' | 'number' | 'boolean' | 'object'
+  description: string
+  validation?: 'non-empty' | 'file-paths' | 'positive-int'
+}
+
+export interface OutputContract {
+  agent: string
+  required_fields: string[]
+  optional_fields: string[]
+  schema: Record<string, FieldSpec>
+}
+
+export interface ContractResult {
+  valid: boolean
+  missing: string[]
+  warnings: string[]
+  data?: Record<string, unknown>
+}
+
+export const AGENT_CONTRACTS: Record<string, OutputContract> = {
+  'developer': {
+    agent: 'developer',
+    required_fields: ['files_changed', 'tests_added', 'summary'],
+    optional_fields: [],
+    schema: {
+      files_changed: { type: 'string[]', description: 'List of file paths created or modified', validation: 'file-paths' },
+      tests_added: { type: 'string[]', description: 'List of test file paths added or modified', validation: 'file-paths' },
+      summary: { type: 'string', description: 'Brief description of what was implemented', validation: 'non-empty' },
+    },
+  },
+  'ui-ux-expert': {
+    agent: 'ui-ux-expert',
+    required_fields: ['files_changed', 'components_created', 'a11y_verified', 'summary'],
+    optional_fields: [],
+    schema: {
+      files_changed: { type: 'string[]', description: 'List of file paths created or modified', validation: 'file-paths' },
+      components_created: { type: 'string[]', description: 'List of new component file paths', validation: 'file-paths' },
+      a11y_verified: { type: 'boolean', description: 'Whether accessibility was verified' },
+      summary: { type: 'string', description: 'Brief description of UI/UX changes', validation: 'non-empty' },
+    },
+  },
+  'testing-expert': {
+    agent: 'testing-expert',
+    required_fields: ['test_files', 'coverage_summary', 'summary'],
+    optional_fields: [],
+    schema: {
+      test_files: { type: 'string[]', description: 'List of test file paths created or modified', validation: 'file-paths' },
+      coverage_summary: { type: 'string', description: 'Summary of test coverage achieved', validation: 'non-empty' },
+      summary: { type: 'string', description: 'Brief description of testing work done', validation: 'non-empty' },
+    },
+  },
+  'security-expert': {
+    agent: 'security-expert',
+    required_fields: ['findings', 'severity', 'files_reviewed', 'summary'],
+    optional_fields: [],
+    schema: {
+      findings: { type: 'string[]', description: 'List of security findings or issues found' },
+      severity: { type: 'string', description: 'Overall severity level (critical|high|medium|low|none)', validation: 'non-empty' },
+      files_reviewed: { type: 'string[]', description: 'List of file paths reviewed', validation: 'file-paths' },
+      summary: { type: 'string', description: 'Summary of security review', validation: 'non-empty' },
+    },
+  },
+  'architect': {
+    agent: 'architect',
+    required_fields: ['decision', 'alternatives_considered', 'risks', 'summary'],
+    optional_fields: [],
+    schema: {
+      decision: { type: 'string', description: 'The architectural decision made', validation: 'non-empty' },
+      alternatives_considered: { type: 'string', description: 'Alternatives that were evaluated', validation: 'non-empty' },
+      risks: { type: 'string', description: 'Known risks of the decision', validation: 'non-empty' },
+      summary: { type: 'string', description: 'Brief summary of the architectural decision', validation: 'non-empty' },
+    },
+  },
+  'researcher': {
+    agent: 'researcher',
+    required_fields: ['findings', 'sources', 'confidence', 'summary'],
+    optional_fields: [],
+    schema: {
+      findings: { type: 'string', description: 'Research findings and conclusions', validation: 'non-empty' },
+      sources: { type: 'string[]', description: 'List of sources referenced' },
+      confidence: { type: 'string', description: 'Confidence level (high|medium|low) with rationale', validation: 'non-empty' },
+      summary: { type: 'string', description: 'Brief summary of research', validation: 'non-empty' },
+    },
+  },
+  'reviewer': {
+    agent: 'reviewer',
+    required_fields: ['verdict', 'issues', 'summary'],
+    optional_fields: [],
+    schema: {
+      verdict: { type: 'string', description: 'Review verdict (pass|block|conditional)', validation: 'non-empty' },
+      issues: { type: 'string[]', description: 'List of issues found during review' },
+      summary: { type: 'string', description: 'Brief review summary', validation: 'non-empty' },
+    },
+  },
+  'documentation-writer': {
+    agent: 'documentation-writer',
+    required_fields: ['files_changed', 'summary'],
+    optional_fields: [],
+    schema: {
+      files_changed: { type: 'string[]', description: 'List of documentation file paths created or modified', validation: 'file-paths' },
+      summary: { type: 'string', description: 'Brief description of documentation changes', validation: 'non-empty' },
+    },
+  },
+  'copywriter': {
+    agent: 'copywriter',
+    required_fields: ['content', 'word_count', 'summary'],
+    optional_fields: [],
+    schema: {
+      content: { type: 'string', description: 'The written content or key excerpts', validation: 'non-empty' },
+      word_count: { type: 'number', description: 'Total word count of written content', validation: 'positive-int' },
+      summary: { type: 'string', description: 'Brief summary of content created', validation: 'non-empty' },
+    },
+  },
+  'performance-expert': {
+    agent: 'performance-expert',
+    required_fields: ['metrics_before', 'metrics_after', 'files_changed', 'summary'],
+    optional_fields: [],
+    schema: {
+      metrics_before: { type: 'object', description: 'Performance metrics before changes' },
+      metrics_after: { type: 'object', description: 'Performance metrics after changes' },
+      files_changed: { type: 'string[]', description: 'List of file paths created or modified', validation: 'file-paths' },
+      summary: { type: 'string', description: 'Summary of performance improvements', validation: 'non-empty' },
+    },
+  },
+  'database-engineer': {
+    agent: 'database-engineer',
+    required_fields: ['migrations', 'rls_policies', 'rollback_plan', 'summary'],
+    optional_fields: [],
+    schema: {
+      migrations: { type: 'string[]', description: 'List of migration file paths applied', validation: 'file-paths' },
+      rls_policies: { type: 'string[]', description: 'List of RLS policy names added or modified' },
+      rollback_plan: { type: 'string', description: 'Steps to roll back the changes if needed', validation: 'non-empty' },
+      summary: { type: 'string', description: 'Summary of database changes', validation: 'non-empty' },
+    },
+  },
+  'devops-expert': {
+    agent: 'devops-expert',
+    required_fields: ['files_changed', 'env_vars_added', 'summary'],
+    optional_fields: [],
+    schema: {
+      files_changed: { type: 'string[]', description: 'List of file paths created or modified', validation: 'file-paths' },
+      env_vars_added: { type: 'string[]', description: 'List of environment variable names added' },
+      summary: { type: 'string', description: 'Summary of DevOps changes', validation: 'non-empty' },
+    },
+  },
+  'api-designer': {
+    agent: 'api-designer',
+    required_fields: ['endpoints', 'schemas', 'summary'],
+    optional_fields: [],
+    schema: {
+      endpoints: { type: 'string[]', description: 'List of API endpoints designed or modified' },
+      schemas: { type: 'string[]', description: 'List of request/response schema names' },
+      summary: { type: 'string', description: 'Summary of API design decisions', validation: 'non-empty' },
+    },
+  },
+  'data-expert': {
+    agent: 'data-expert',
+    required_fields: ['pipeline_steps', 'files_changed', 'summary'],
+    optional_fields: [],
+    schema: {
+      pipeline_steps: { type: 'string[]', description: 'List of data pipeline steps implemented' },
+      files_changed: { type: 'string[]', description: 'List of file paths created or modified', validation: 'file-paths' },
+      summary: { type: 'string', description: 'Summary of data engineering work', validation: 'non-empty' },
+    },
+  },
+  'seo-specialist': {
+    agent: 'seo-specialist',
+    required_fields: ['files_changed', 'tags_added', 'summary'],
+    optional_fields: [],
+    schema: {
+      files_changed: { type: 'string[]', description: 'List of file paths created or modified', validation: 'file-paths' },
+      tags_added: { type: 'string[]', description: 'List of SEO tags or structured data items added' },
+      summary: { type: 'string', description: 'Summary of SEO changes', validation: 'non-empty' },
+    },
+  },
+  'release-manager': {
+    agent: 'release-manager',
+    required_fields: ['version', 'changelog_entries', 'checks_passed', 'summary'],
+    optional_fields: [],
+    schema: {
+      version: { type: 'string', description: 'The version string being released (e.g. 1.2.3)', validation: 'non-empty' },
+      changelog_entries: { type: 'string[]', description: 'List of changelog entries for this release' },
+      checks_passed: { type: 'boolean', description: 'Whether all release checks passed' },
+      summary: { type: 'string', description: 'Summary of the release', validation: 'non-empty' },
+    },
+  },
+}
+
+function applyValidation(
+  field: string,
+  value: unknown,
+  spec: FieldSpec,
+  missing: string[],
+): void {
+  if (spec.validation === 'non-empty') {
+    if (typeof value !== 'string' || value.trim() === '') {
+      missing.push(field)
+    }
+  } else if (spec.validation === 'file-paths') {
+    if (!Array.isArray(value) || !value.every(v => typeof v === 'string')) {
+      missing.push(field)
+    }
+  } else if (spec.validation === 'positive-int') {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+      missing.push(field)
+    }
+  }
+}
+
+export function validateOutput(agent: string, output: string): ContractResult {
+  const contract = AGENT_CONTRACTS[agent.toLowerCase()]
+  if (!contract) {
+    return { valid: true, missing: [], warnings: ['no_contract_defined'] }
+  }
+
+  const blockMatch = output.match(/<!--\s*OUTPUT_CONTRACT\s*([\s\S]*?)-->/)
+  if (!blockMatch) {
+    return { valid: false, missing: ['__contract_block'], warnings: [] }
+  }
+
+  let data: Record<string, unknown>
+  try {
+    data = JSON.parse(blockMatch[1].trim()) as Record<string, unknown>
+  } catch {
+    return { valid: false, missing: ['__contract_block'], warnings: ['invalid_json'] }
+  }
+
+  const missing: string[] = []
+
+  for (const field of contract.required_fields) {
+    if (!(field in data) || data[field] === null || data[field] === undefined) {
+      missing.push(field)
+      continue
+    }
+    const fieldSpec = contract.schema[field]
+    if (fieldSpec?.validation) {
+      applyValidation(field, data[field], fieldSpec, missing)
+    }
+  }
+
+  return { valid: missing.length === 0, missing, warnings: [], data }
+}
+
+export function buildContractInstruction(agent: string): string | null {
+  const contract = AGENT_CONTRACTS[agent.toLowerCase()]
+  if (!contract) return null
+
+  const exampleFields = contract.required_fields
+    .map(f => {
+      const spec = contract.schema[f]
+      if (!spec) return `"${f}": "..."`
+      if (spec.type === 'string[]') return `"${f}": [...]`
+      if (spec.type === 'boolean') return `"${f}": true`
+      if (spec.type === 'number') return `"${f}": 0`
+      if (spec.type === 'object') return `"${f}": {}`
+      return `"${f}": "..."`
+    })
+    .join(', ')
+
+  return [
+    '## Output Contract (REQUIRED)',
+    'At the END of your response, include an OUTPUT_CONTRACT block:',
+    `<!-- OUTPUT_CONTRACT`,
+    `{ ${exampleFields} }`,
+    `-->`,
+    `The following fields are REQUIRED: ${contract.required_fields.join(', ')}`,
+  ].join('\n')
+}
+
+export function buildContractRetryPrompt(result: ContractResult): string {
+  return [
+    'Your previous output was missing the required OUTPUT_CONTRACT block.',
+    'At the END of your response, include:',
+    '<!-- OUTPUT_CONTRACT',
+    '{ ... }',
+    '-->',
+    `Missing fields: ${result.missing.join(', ')}`,
+  ].join('\n')
+}