Build a coding assistant

// tools.js
import { execFile } from 'node:child_process'
import { promisify } from 'node:util'
import fs from 'node:fs/promises'
import path from 'node:path'
 
const run = promisify(execFile)
const ROOT = path.resolve(process.env.REPO_DIR ?? '.')
 
function inside(p) {
  const full = path.resolve(ROOT, p)
  if (!full.startsWith(ROOT + path.sep)) throw new Error('path outside repository')
  return full
}
 
export const TOOLS = [
  {
    type: 'function',
    function: {
      name: 'read_file',
      description: 'Read a file from the repository. Returns at most 400 lines starting at start_line.',
      parameters: {
        type: 'object',
        properties: { path: { type: 'string' }, start_line: { type: 'integer', minimum: 1 } },
        required: ['path'],
      },
    },
  },
  {
    type: 'function',
    function: {
      name: 'search_code',
      description: 'Search the repository for a literal string. Returns up to 50 matching lines as path:line: text.',
      parameters: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
    },
  },
  {
    type: 'function',
    function: {
      name: 'run_tests',
      description: 'Run the project test suite and return the last 150 lines of output and the exit code.',
      parameters: { type: 'object', properties: {} },
    },
  },
]
 
export async function runTool(name, args) {
  if (name === 'read_file') {
    const lines = (await fs.readFile(inside(args.path), 'utf8')).split('\n')
    const start = Math.max(1, args.start_line ?? 1)
    return lines.slice(start - 1, start + 399).map((l, i) => `${start + i}: ${l}`).join('\n')
  }
  if (name === 'search_code') {
    const { stdout } = await run('git', ['grep', '-n', '-F', '--', args.query], { cwd: ROOT }).catch((e) => e)
    return (stdout ?? '').split('\n').slice(0, 50).join('\n') || 'no matches'
  }
  if (name === 'run_tests') {
    const r = await run('npm', ['test', '--silent'], { cwd: ROOT, timeout: 300_000 }).catch((e) => e)
    const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.split('\n').slice(-150).join('\n')
    return `exit code ${r.code ?? 0}\n${out}`
  }
  return `unknown tool ${name}`
}

// review.js  (REPO_DIR=../my-repo node review.js main feature/new-checkout)
import { execFileSync } from 'node:child_process'
import { TOOLS, runTool } from './tools.js'
 
const [base, head] = process.argv.slice(2)
const diff = execFileSync('git', ['diff', `${base}...${head}`], { cwd: process.env.REPO_DIR, encoding: 'utf8' })
 
const SYSTEM = `
You review pull requests for a TypeScript web shop.
Use the tools to read surrounding code and to run the tests before concluding.
Report in Markdown with three sections:
## Bugs: problems that would cause wrong behaviour, each with file:line and a suggested fix.
## Risks: missing tests, unclear error handling, security concerns.
## Nits: naming and style, at most five.
Say "None" for an empty section. Do not report something as a bug unless you have read the code that proves it.
`.trim()
 
async function chat(messages) {
  const res = await fetch('https://app.syntic.ai/v1/chat/completions', {
    method: 'POST',
    headers: { Authorization: `Bearer ${process.env.SYNTIC_API_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: 'Syntic Code', stream: false, max_tokens: 4000, tools: TOOLS, messages }),
  })
  const data = await res.json()
  if (!res.ok) throw new Error(`${res.status} ${data.error}: ${data.detail ?? data.message ?? ''}`)
  return data
}
 
const messages = [
  { role: 'system', content: SYSTEM },
  { role: 'user', content: `Review this diff (${base}...${head}):\n\n<diff>\n${diff}\n</diff>` },
]
 
let tokens = 0
for (let step = 0; step < 25; step++) {
  const data = await chat(messages)
  tokens += data.usage.total_tokens
  const msg = data.choices[0].message
  messages.push(msg)
  if (!msg.tool_calls?.length) {
    console.log(msg.content)
    console.error(`\n${step + 1} requests, ${tokens} tokens`)
    process.exit(0)
  }
  for (const call of msg.tool_calls) {
    let result
    try {
      result = await runTool(call.function.name, JSON.parse(call.function.arguments || '{}'))
    } catch (err) {
      result = `error: ${err.message}`
    }
    messages.push({ role: 'tool', tool_call_id: call.id, content: String(result) })
  }
}
console.error('Stopped after 25 steps without a final review.')
process.exit(1)

{
  type: 'function',
  function: {
    name: 'propose_patch',
    description: 'Suggest a fix as a unified diff against the head branch. The patch is reviewed by a person; it is not applied automatically.',
    parameters: {
      type: 'object',
      properties: { title: { type: 'string' }, diff: { type: 'string' } },
      required: ['title', 'diff'],
    },
  },
}

# .github/workflows/review.yml (excerpt)
- name: AI review
  env:
    SYNTIC_API_KEY: ${{ secrets.SYNTIC_API_KEY }}
    REPO_DIR: ${{ github.workspace }}
  run: node review/review.js origin/${{ github.base_ref }} HEAD > review.md