Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

2.7 KB
Raw Blame
import assert from 'node:assert/strict'
import { execFileSync } from 'node:child_process'
import { readFileSync } from 'node:fs'
import { dirname, resolve } from 'node:path'
import { performance } from 'node:perf_hooks'
import { build } from 'esbuild'
import { buildCounterbalancedSchedule } from './counterbalanced-benchmark-schedule.mjs'

const baseline = process.argv[2]
if (!baseline) {
  throw new Error(
    'Usage: node config/scripts/mobile-history-scope-paths-benchmark.mjs <baseline-ref>'
  )
}
const file = 'mobile/src/agent-history/agent-history-scope-paths.ts'
async function load(contents) {
  const result = await build({
    stdin: { contents, loader: 'ts', resolveDir: dirname(resolve(file)) },
    bundle: true,
    platform: 'node',
    format: 'esm',
    write: false,
    logLevel: 'silent',
    tsconfigRaw: {}
  })
  return (
    await import(
      `data:text/javascript;base64,${Buffer.from(result.outputFiles[0].text).toString('base64')}`
    )
  ).deriveMobileAiVaultScopePaths
}
const arms = {
  before: await load(execFileSync('git', ['show', `${baseline}:${file}`], { encoding: 'utf8' })),
  after: await load(readFileSync(file, 'utf8'))
}
const iterations = 200
const results = []
for (const [count, unique] of [
  [1, 1],
  [16, 16],
  [64, 64],
  [1000, 32]
]) {
  for (const root of ['/home/ada/café/project', 'C:\\Users\\ada\\café\\project']) {
    const rows = Array.from({ length: count }, (_, index) => ({
      worktreeId: `w-${index}`,
      repoId: 'repo',
      path: `${root}/workspace-${index % unique}`
    }))
    const expected = arms.before('project', rows[0], rows)
    assert.deepEqual(arms.after('project', rows[0], rows), expected)
    const samples = { before: [], after: [] }
    function run(arm) {
      let length = 0
      const start = performance.now()
      for (let i = 0; i < iterations; i++) {
        length += arms[arm]('project', rows[0], rows).length
      }
      const elapsed = performance.now() - start
      assert.equal(length, iterations * expected.length)
      return elapsed / iterations
    }
    for (const arm of ['before', 'after']) {
      run(arm)
    }
    for (const pair of buildCounterbalancedSchedule(10, 'before', 'after')) {
      for (const arm of pair) {
        samples[arm].push(run(arm))
      }
    }
    const median = (values) => {
      const sorted = [...values].sort((a, b) => a - b)
      return (sorted[4] + sorted[5]) / 2
    }
    results.push({
      count,
      unique,
      root,
      beforeMs: median(samples.before),
      afterMs: median(samples.after),
      samples
    })
  }
}
console.log(
  JSON.stringify(
    { baseline, node: process.version, platform: process.platform, iterations, results },
    null,
    2
  )
)