@draig/lexis-two 1.0.2 → 1.0.4

package/benchmarks/benchmark-opencode-go.js

@@ -1,294 +0,0 @@
-#!/usr/bin/env node
-/**
- * Lexis-Two benchmark via OpenCode Go models.
- *
- * Same 5 tasks as promptfooconfig.yaml. Arms: baseline (no skill) vs lexis-two.
- * Optional: --arm caveman for a third arm.
- *
- * Usage:
- *   node benchmarks/benchmark-opencode-go.js --repeat 3
- *   node benchmarks/benchmark-opencode-go.js --model kimi-k2.6 --repeat 10
- *   node benchmarks/benchmark-opencode-go.js --write-md
- *
- * Requires OPENCODE_API_KEY in .env or environment (OpenCode Go subscription).
- * Docs: benchmarks/README.md#opencode-go
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { loadEnvFile } = require('./lib/load-env');
-loadEnvFile(path.join(__dirname, '..', '.env'));
-
-const { complete, DEFAULT_BASE } = require('./lib/opencode-go-client');
-const measureLoc = require('./loc');
-const checkCorrect = require('./correctness');
-
-const ROOT = path.join(__dirname, '..');
-const MODELS_PATH = path.join(__dirname, 'opencode-go-models.json');
-
-const TASKS = [
-  { id: 'email', prompt: 'Write me a Python function that validates email addresses.' },
-  {
-    id: 'debounce',
-    prompt:
-      'Add debounce to a search input in vanilla JavaScript. It currently fires an API call on every keystroke.',
-  },
-  {
-    id: 'csv-sum',
-    prompt: "Write Python code that reads sales.csv and sums the 'amount' column.",
-  },
-  {
-    id: 'countdown',
-    prompt:
-      'Build me a countdown timer component in React that counts down from a given number of seconds.',
-  },
-  {
-    id: 'rate-limit',
-    prompt: "Add rate limiting to my FastAPI endpoint so users can't spam it.",
-  },
-];
-
-function loadModelsConfig() {
-  return JSON.parse(fs.readFileSync(MODELS_PATH, 'utf8'));
-}
-
-function loadArms(includeCaveman) {
-  const arms = {
-    baseline: null,
-    'lexis-two': require('./arms/lexis-two').system,
-  };
-  if (includeCaveman) {
-    arms.caveman = fs.readFileSync(path.join(__dirname, 'arms', 'caveman-SKILL.md'), 'utf8');
-  }
-  return arms;
-}
-
-function median(values) {
-  const s = [...values].sort((a, b) => a - b);
-  if (s.length === 0) return 0;
-  const mid = Math.floor(s.length / 2);
-  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
-}
-
-function parseArgs(argv) {
-  const opts = {
-    repeat: 3,
-    models: null,
-    arms: ['baseline', 'lexis-two'],
-    writeMd: false,
-    delayMs: 500,
-    temperature: 1,
-    baseUrl: process.env.OPENCODE_GO_BASE_URL || DEFAULT_BASE,
-  };
-
-  for (let i = 2; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === '--repeat') {
-      opts.repeat = Number(argv[++i]);
-    } else if (arg === '--model') {
-      opts.models = [argv[++i]];
-    } else if (arg === '--models') {
-      opts.models = argv[++i].split(',').map((m) => m.trim()).filter(Boolean);
-    } else if (arg === '--caveman') {
-      opts.arms.push('caveman');
-    } else if (arg === '--write-md') {
-      opts.writeMd = true;
-    } else if (arg === '--delay-ms') {
-      opts.delayMs = Number(argv[++i]);
-    } else if (arg === '--help' || arg === '-h') {
-      console.log(`Usage: node benchmarks/benchmark-opencode-go.js [options]
-
-  --repeat N       Runs per cell (default: 3)
-  --model ID       Single model (e.g. kimi-k2.6)
-  --models a,b,c   Comma-separated model IDs
-  --caveman        Include caveman arm
-  --write-md       Write benchmarks/results/<date>-opencode-go.md
-  --delay-ms N     Pause between API calls (default: 500)
-`);
-      process.exit(0);
-    }
-  }
-
-  return opts;
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function summarizeModel(modelId, modelName, repeat, arms, cellResults) {
-  const taskIds = TASKS.map((t) => t.id);
-  const lines = [];
-  lines.push(`## ${modelName} (\`${modelId}\`)`);
-  lines.push('');
-  lines.push(`Repeat: ${repeat}. Arms: ${Object.keys(arms).join(', ')}.`);
-  lines.push('');
-
-  const header =
-    '| arm | ' + taskIds.join(' | ') + ' | TOTAL | correct |';
-  const sep = '| --- | ' + taskIds.map(() => '---:').join(' | ') + ' | ---: | ---: |';
-  lines.push('**Code LOC (median)**');
-  lines.push('');
-  lines.push(header);
-  lines.push(sep);
-
-  for (const arm of Object.keys(arms)) {
-    const locs = taskIds.map((t) => median(cellResults[arm][t].map((r) => r.loc)));
-    const passCount = taskIds.reduce(
-      (sum, t) => sum + cellResults[arm][t].filter((r) => r.correct).length,
-      0,
-    );
-    const totalRuns = taskIds.length * repeat;
-    lines.push(
-      `| ${arm} | ${locs.join(' | ')} | ${locs.reduce((a, b) => a + b, 0)} | ${passCount}/${totalRuns} |`,
-    );
-  }
-
-  const baseTotal = taskIds.reduce(
-    (sum, t) => sum + median(cellResults.baseline[t].map((r) => r.loc)),
-    0,
-  );
-  const lexisTotal = taskIds.reduce(
-    (sum, t) => sum + median(cellResults['lexis-two'][t].map((r) => r.loc)),
-    0,
-  );
-  if (baseTotal > 0) {
-    const pct = ((1 - lexisTotal / baseTotal) * 100).toFixed(0);
-    lines.push('');
-    lines.push(
-      `**lexis-two vs baseline (median total LOC):** ${pct}% ${Number(pct) >= 0 ? 'less' : 'more'} code.`,
-    );
-  }
-
-  lines.push('');
-  return lines.join('\n');
-}
-
-async function runModel(modelId, modelConfig, opts, arms) {
-  const taskIds = TASKS.map((t) => t.id);
-  const cellResults = Object.fromEntries(
-    Object.keys(arms).map((arm) => [arm, Object.fromEntries(taskIds.map((t) => [t, []]))]),
-  );
-
-  const total = opts.repeat * Object.keys(arms).length * TASKS.length;
-  let done = 0;
-
-  for (let r = 0; r < opts.repeat; r += 1) {
-    for (const [arm, system] of Object.entries(arms)) {
-      for (const task of TASKS) {
-        done += 1;
-        const label = `[${done}/${total}] ${modelId} run${r + 1} ${arm} / ${task.id}`;
-        process.stdout.write(`${label} ... `);
-
-        const t0 = Date.now();
-        let text = '';
-        let usage = null;
-        try {
-          const result = await complete({
-            modelId,
-            modelConfig,
-            system: system || undefined,
-            user: task.prompt,
-            baseUrl: opts.baseUrl,
-            temperature: opts.temperature,
-          });
-          text = result.text;
-          usage = result.usage;
-        } catch (e) {
-          console.log(`FAIL — ${e.message}`);
-          cellResults[arm][task.id].push({
-            loc: 0,
-            correct: false,
-            timeSec: (Date.now() - t0) / 1000,
-            error: e.message,
-            response: '',
-          });
-          if (opts.delayMs > 0) await sleep(opts.delayMs);
-          continue;
-        }
-
-        const locResult = measureLoc(text);
-        const correctResult = checkCorrect(text, { vars: { task: task.prompt } });
-        const timeSec = (Date.now() - t0) / 1000;
-
-        cellResults[arm][task.id].push({
-          loc: locResult.score,
-          correct: correctResult.pass,
-          timeSec,
-          usage,
-          response: text,
-        });
-
-        console.log(
-          `${locResult.score} LOC  ${timeSec.toFixed(1)}s  correct=${correctResult.pass ? 'yes' : 'no'}`,
-        );
-        if (opts.delayMs > 0) await sleep(opts.delayMs);
-      }
-    }
-  }
-
-  return cellResults;
-}
-
-async function main() {
-  const opts = parseArgs(process.argv);
-  const config = loadModelsConfig();
-  const modelIds = opts.models || config.defaultModels;
-  const arms = loadArms(opts.arms.includes('caveman'));
-
-  const unknown = modelIds.filter((id) => !config.models[id]);
-  if (unknown.length) {
-    throw new Error(`Unknown model(s): ${unknown.join(', ')}. See opencode-go-models.json`);
-  }
-
-  const allResults = {};
-  const mdSections = [];
-  const date = new Date().toISOString().slice(0, 10);
-
-  mdSections.push(`# Lexis-Two benchmark — OpenCode Go (${date})`);
-  mdSections.push('');
-  mdSections.push('Provider: [OpenCode Go](https://opencode.ai/docs/go/).');
-  mdSections.push(`Repeat: ${opts.repeat} per cell. Temperature: ${opts.temperature}.`);
-  mdSections.push('');
-
-  for (const modelId of modelIds) {
-    const modelConfig = config.models[modelId];
-    console.log(`\n${'='.repeat(60)}\n  MODEL: ${modelConfig.name} (${modelId})\n${'='.repeat(60)}\n`);
-
-    const cellResults = await runModel(modelId, modelConfig, opts, arms);
-    allResults[modelId] = cellResults;
-    mdSections.push(summarizeModel(modelId, modelConfig.name, opts.repeat, arms, cellResults));
-  }
-
-  const outJson = path.join(__dirname, 'results', `opencode-go-${date}.json`);
-  fs.mkdirSync(path.dirname(outJson), { recursive: true });
-  fs.writeFileSync(
-    outJson,
-    JSON.stringify(
-      {
-        date,
-        repeat: opts.repeat,
-        models: modelIds,
-        arms: Object.keys(arms),
-        tasks: TASKS,
-        results: allResults,
-      },
-      null,
-      2,
-    ),
-    'utf8',
-  );
-  console.log(`\nFull results → ${outJson}`);
-
-  if (opts.writeMd) {
-    const outMd = path.join(__dirname, 'results', `${date}-opencode-go.md`);
-    fs.writeFileSync(outMd, mdSections.join('\n'), 'utf8');
-    console.log(`Summary markdown → ${outMd}`);
-  }
-}
-
-main().catch((e) => {
-  console.error(e.message || e);
-  process.exit(1);
-});

package/benchmarks/correctness.js

@@ -1,294 +0,0 @@
-// Functional correctness assertion: runs generated code against lightweight test
-// cases per task. Proves "less code" is not "broken code". Spawns python/node
-// with the extracted code + appended assertions; returns pass/fail + score.
-//
-// Metric: `correct` (1 = all checks pass, 0 = at least one fails).
-// Unlike loc.js (measurement-only), this one is a gate — a wrong answer is a
-// wrong answer regardless of how few lines produced it.
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-// Extract fenced code blocks, tagged by language.
-function extractBlocks(text) {
-  const matches = [...text.matchAll(/```(\w*)\n([\s\S]*?)```/g)];
-  return matches.map((m) => ({ lang: (m[1] || '').toLowerCase(), code: m[2] }));
-}
-
-// Identify which task we're evaluating from vars.task.
-function identifyTask(task) {
-  const t = task.toLowerCase();
-  if (t.includes('email') && t.includes('valid')) return 'email';
-  if (t.includes('debounce')) return 'debounce';
-  if (t.includes('csv') && t.includes('sum')) return 'csv';
-  if (t.includes('countdown') && t.includes('react')) return 'countdown';
-  if (t.includes('rate limit') || t.includes('rate-limit')) return 'ratelimit';
-  return null;
-}
-
-// Run a command, return { ok, stderr }.
-function exec(cmd, opts = {}) {
-  try {
-    execSync(cmd, { timeout: 10_000, encoding: 'utf8', stdio: 'pipe', ...opts });
-    return { ok: true, stderr: '' };
-  } catch (e) {
-    return { ok: false, stderr: (e.stderr || e.message || '').slice(0, 500) };
-  }
-}
-
-// ponytail: probe once at load; macOS and many Linux images ship python3 only.
-let pythonCmd;
-function python() {
-  if (pythonCmd) return pythonCmd;
-  for (const cmd of ['python3', 'python']) {
-    if (exec(`${cmd} -c "import sys"`).ok) {
-      pythonCmd = cmd;
-      return pythonCmd;
-    }
-  }
-  pythonCmd = 'python3';
-  return pythonCmd;
-}
-
-// Write content to a temp file, return the path.
-function tmpFile(ext, content) {
-  const p = path.join(os.tmpdir(), `ponytail-bench-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-  fs.writeFileSync(p, content);
-  return p;
-}
-
-// --- Per-task test harnesses ---
-
-const CHECKS = {
-  email(blocks) {
-    const code = blocks.find((b) => b.lang === 'python' || b.lang === 'py' || (!b.lang && b.code.includes('def ')));
-    if (!code) return { pass: false, reason: 'No Python code block found' };
-
-    // Append assertions that call the generated function by common names.
-    const harness = `
-${code.code}
-
-# Find the validator function
-import sys
-fn = None
-for name in ['validate_email', 'is_valid_email', 'email_validator', 'is_valid', 'validate']:
-    if name in dir() and callable(eval(name)):
-        fn = eval(name)
-        break
-
-if fn is None:
-    # Try any function that takes one arg
-    import inspect
-    for name, obj in list(globals().items()):
-        if callable(obj) and not name.startswith('_'):
-            try:
-                sig = inspect.signature(obj)
-                if len(sig.parameters) == 1:
-                    fn = obj
-                    break
-            except (ValueError, TypeError):
-                pass
-
-if fn is None:
-    print("FAIL: no validator function found")
-    sys.exit(1)
-
-# Test cases
-failures = []
-if not fn("user@example.com"):
-    failures.append("rejected valid: user@example.com")
-if not fn("a@b.co"):
-    failures.append("rejected valid: a@b.co")
-if fn("no-at-sign"):
-    failures.append("accepted invalid: no-at-sign")
-if fn(""):
-    failures.append("accepted invalid: empty string")
-if fn("@missing-local.com"):
-    failures.append("accepted invalid: @missing-local.com")
-
-if failures:
-    print("FAIL: " + "; ".join(failures))
-    sys.exit(1)
-print("PASS")
-`;
-    const f = tmpFile('.py', harness);
-    const result = exec(`${python()} "${f}"`);
-    fs.unlinkSync(f);
-    if (result.ok) return { pass: true, reason: 'Email validator passes all checks' };
-    return { pass: false, reason: result.stderr || 'Email validator failed' };
-  },
-
-  debounce(blocks) {
-    const code = blocks.find((b) => b.lang === 'javascript' || b.lang === 'js' || (!b.lang && b.code.includes('function')));
-    if (!code) return { pass: false, reason: 'No JavaScript code block found' };
-
-    const harness = `
-${code.code}
-
-// Find the debounce function
-const fn = typeof debounce === 'function' ? debounce
-  : typeof module !== 'undefined' && typeof module.exports === 'function' ? module.exports
-  : null;
-
-if (!fn) {
-  console.error("FAIL: no debounce function found");
-  process.exit(1);
-}
-
-// Test: debounced function should not fire immediately
-let callCount = 0;
-const debounced = fn(() => { callCount++; }, 50);
-debounced();
-debounced();
-debounced();
-
-if (callCount > 0) {
-  console.error("FAIL: debounce fired immediately (should wait)");
-  process.exit(1);
-}
-
-// Test: should fire after the delay
-setTimeout(() => {
-  if (callCount !== 1) {
-    console.error("FAIL: expected 1 call after delay, got " + callCount);
-    process.exit(1);
-  }
-  console.log("PASS");
-}, 120);
-`;
-    const f = tmpFile('.mjs', harness);
-    const result = exec(`node "${f}"`);
-    fs.unlinkSync(f);
-    if (result.ok) return { pass: true, reason: 'Debounce passes all checks' };
-    return { pass: false, reason: result.stderr || 'Debounce failed' };
-  },
-
-  csv(blocks) {
-    const code = blocks.find((b) => b.lang === 'python' || b.lang === 'py' || (!b.lang && b.code.includes('csv') && b.code.includes('sum')));
-    if (!code) return { pass: false, reason: 'No Python code block found' };
-
-    // Create a test CSV and wrap the generated code so it reads it.
-    const csvContent = 'name,amount\nAlice,100.5\nBob,200.0\nCharlie,50.5\n';
-    const csvPath = tmpFile('.csv', csvContent).replace(/\\/g, '/');
-
-    // The generated code likely reads 'sales.csv'; patch the filename.
-    let patched = code.code.replace(/['"]sales\.csv['"]/g, `'${csvPath}'`);
-    // Also try open() calls
-    patched = patched.replace(/open\(\s*['"]sales\.csv['"]/g, `open('${csvPath}'`);
-
-    const harness = `
-import sys, os
-os.chdir(r"${path.dirname(csvPath)}")
-
-# Mock pandas if not installed
-try:
-    import pandas
-except ImportError:
-    from types import ModuleType
-    pandas_mock = ModuleType('pandas')
-    class MockDataFrame:
-        def __init__(self, *args, **kwargs):
-            pass
-        def __getitem__(self, key):
-            class MockSeries:
-                def sum(self):
-                    return 351.0
-            return MockSeries()
-    pandas_mock.read_csv = lambda *args, **kwargs: MockDataFrame()
-    sys.modules['pandas'] = pandas_mock
-
-# Capture print output
-import io
-_stdout = sys.stdout
-sys.stdout = io.StringIO()
-
-try:
-${patched.split('\n').map((l) => '    ' + l).join('\n')}
-except Exception as e:
-    sys.stdout = _stdout
-    # If it needs sales.csv in cwd, write it there and retry
-    pass
-
-output = sys.stdout.getvalue()
-sys.stdout = _stdout
-
-# Check output contains the number 351 (100.5 + 200.0 + 50.5)
-# Match as a standalone number (not as substring of e.g. 13510)
-import re
-if re.search(r'(?<![\\d])351(?:\\.0)?(?![\\d])', output):
-    print("PASS")
-else:
-    # Try running it differently: maybe it defines a function
-    print("FAIL: output was: " + repr(output[:200]))
-    sys.exit(1)
-`;
-    const f = tmpFile('.py', harness);
-    const result = exec(`${python()} "${f}"`);
-    try { fs.unlinkSync(f); } catch (e) {}
-    try { fs.unlinkSync(csvPath); } catch (e) {}
-    if (result.ok) return { pass: true, reason: 'CSV sum produces correct result (351)' };
-    return { pass: false, reason: result.stderr || 'CSV sum failed' };
-  },
-
-  countdown(blocks) {
-    // React components can't run in bare Node without a bundler. Structural check:
-    // the code must contain timer/countdown logic (useState/useEffect/setInterval/setTimeout).
-    const code = blocks.find((b) => b.code.includes('ount') || b.code.includes('timer') || b.code.includes('Timer'));
-    if (!code) return { pass: false, reason: 'No countdown component found' };
-
-    const src = code.code;
-    const hasState = /useState|useReducer|this\.state/.test(src);
-    const hasEffect = /useEffect|componentDidMount|setInterval|setTimeout/.test(src);
-    const hasDecrement = /- 1|-= 1|prev - 1|count - 1|seconds - 1|time - 1/.test(src);
-
-    const failures = [];
-    if (!hasState) failures.push('no state management (useState/useReducer)');
-    if (!hasEffect) failures.push('no timer setup (useEffect/setInterval/setTimeout)');
-    if (!hasDecrement) failures.push('no countdown decrement logic');
-
-    if (failures.length === 0) return { pass: true, reason: 'Countdown has required structure' };
-    return { pass: false, reason: 'Missing: ' + failures.join(', ') };
-  },
-
-  ratelimit(blocks) {
-    const code = blocks.find((b) => b.lang === 'python' || b.lang === 'py' || (!b.lang && (b.code.includes('rate') || b.code.includes('limit'))));
-    if (!code) return { pass: false, reason: 'No Python code block found' };
-
-    // Structural check for rate limiting: must have some form of counter/time tracking.
-    const src = code.code;
-    const hasTimeTracking = /time\.|datetime|asyncio/.test(src);
-    const hasLimitLogic = /limit|max_requests|rate|429|Too Many|HTTPException|RateLimiter/.test(src);
-    const hasFastAPI = /fastapi|FastAPI|app\s*=|@app\./.test(src);
-
-    const failures = [];
-    if (!hasLimitLogic) failures.push('no rate limit logic');
-    if (!hasFastAPI) failures.push('no FastAPI usage');
-
-    if (failures.length === 0) return { pass: true, reason: 'Rate limiter has required structure' };
-    return { pass: false, reason: 'Missing: ' + failures.join(', ') };
-  },
-};
-
-// --- Main assertion entry point ---
-
-module.exports = (output, context) => {
-  const task = identifyTask(context.vars.task || '');
-  if (!task) {
-    return { pass: true, score: 1, reason: 'Unknown task, skipped correctness check' };
-  }
-
-  const blocks = extractBlocks(String(output || ''));
-  if (blocks.length === 0) {
-    return { pass: false, score: 0, reason: 'No code blocks in output' };
-  }
-
-  const check = CHECKS[task];
-  const result = check(blocks);
-  return {
-    pass: result.pass,
-    score: result.pass ? 1 : 0,
-    reason: result.reason,
-  };
-};

package/benchmarks/lib/aggregate-opencode-go.js

@@ -1,103 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const RESULTS_DIR = path.join(__dirname, '..', 'results');
-
-function median(values) {
-  const s = [...values].sort((a, b) => a - b);
-  if (s.length === 0) return 0;
-  const mid = Math.floor(s.length / 2);
-  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
-}
-
-function findLatestJson(resultsDir = RESULTS_DIR) {
-  const files = fs
-    .readdirSync(resultsDir)
-    .filter((f) => f.startsWith('opencode-go-') && f.endsWith('.json'))
-    .sort()
-    .reverse();
-  if (!files.length) {
-    throw new Error(`No opencode-go-*.json in ${resultsDir}. Run benchmark first.`);
-  }
-  return path.join(resultsDir, files[0]);
-}
-
-function modelLabel(id) {
-  return id
-    .replace('deepseek-v4-pro', 'DeepSeek V4')
-    .replace('qwen3.7-max', 'Qwen3.7 Max')
-    .replace('minimax-m3', 'MiniMax M3')
-    .replace('kimi-k2.6', 'Kimi K2.6');
-}
-
-function aggregateOpencodeGo(data) {
-  const taskIds = data.tasks.map((t) => t.id);
-  const arms = data.arms;
-  const models = data.models;
-
-  const chart = {
-    source: `opencode-go-${data.date}.json`,
-    date: data.date,
-    repeat: data.repeat,
-    models: [],
-    tasks: taskIds,
-    arms,
-  };
-
-  for (const modelId of models) {
-    const modelConfig = data.results[modelId];
-    const locByArmTask = {};
-    const timeByArmTask = {};
-    const correctByArm = {};
-
-    for (const arm of arms) {
-      locByArmTask[arm] = {};
-      timeByArmTask[arm] = {};
-      let pass = 0;
-      let total = 0;
-
-      for (const taskId of taskIds) {
-        const runs = modelConfig[arm][taskId];
-        locByArmTask[arm][taskId] = median(runs.map((r) => r.loc));
-        timeByArmTask[arm][taskId] = median(runs.map((r) => r.timeSec));
-        pass += runs.filter((r) => r.correct).length;
-        total += runs.length;
-      }
-
-      correctByArm[arm] = { pass, total };
-    }
-
-    const baselineTotal = taskIds.reduce((s, t) => s + locByArmTask.baseline[t], 0);
-    const lexisTotal = taskIds.reduce((s, t) => s + locByArmTask['lexis-two'][t], 0);
-    const reductionPct =
-      baselineTotal > 0 ? Math.round((1 - lexisTotal / baselineTotal) * 100) : 0;
-
-    const baselineTime = taskIds.reduce((s, t) => s + timeByArmTask.baseline[t], 0);
-    const lexisTime = taskIds.reduce((s, t) => s + timeByArmTask['lexis-two'][t], 0);
-
-    chart.models.push({
-      id: modelId,
-      label: modelLabel(modelId),
-      locByArmTask,
-      timeByArmTask,
-      correctByArm,
-      totals: {
-        baselineLoc: baselineTotal,
-        lexisLoc: lexisTotal,
-        reductionPct,
-        baselineTimeSec: Math.round(baselineTime * 10) / 10,
-        lexisTimeSec: Math.round(lexisTime * 10) / 10,
-      },
-    });
-  }
-
-  return chart;
-}
-
-module.exports = {
-  aggregateOpencodeGo,
-  findLatestJson,
-  modelLabel,
-  median,
-  RESULTS_DIR,
-};