@codragraph/cli 1.6.2

package/dist/types/pipeline.d.ts

@@ -0,0 +1,18 @@
+import type { KnowledgeGraph } from '../core/graph/types.js';
+import { CommunityDetectionResult } from '../core/ingestion/community-processor.js';
+import { ProcessDetectionResult } from '../core/ingestion/process-processor.js';
+export interface PipelineResult {
+    graph: KnowledgeGraph;
+    /** Absolute path to the repo root — used for lazy file reads during LadybugDB loading */
+    repoPath: string;
+    /** Total files scanned (for stats) */
+    totalFileCount: number;
+    communityResult?: CommunityDetectionResult;
+    processResult?: ProcessDetectionResult;
+    /**
+     * True if the parse phase spawned a worker pool for this run. False means
+     * the sequential fallback handled every chunk. Primarily a test affordance
+     * so regression suites can prove which path executed.
+     */
+    usedWorkerPool: boolean;
+}

package/dist/types/pipeline.js

@@ -0,0 +1 @@
+export {};

package/hooks/claude/codragraph-hook.cjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+/**
+ * CodraGraph Claude Code Hook
+ *
+ * PreToolUse  — intercepts Grep/Glob/Bash searches and augments
+ *               with graph context from the CodraGraph index.
+ * PostToolUse — detects stale index after git mutations and notifies
+ *               the agent to reindex.
+ *
+ * NOTE: SessionStart hooks are broken on Windows (Claude Code bug).
+ * Session context is injected via CLAUDE.md / skills instead.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+/**
+ * Read JSON input from stdin synchronously.
+ */
+function readInput() {
+  try {
+    const data = fs.readFileSync(0, 'utf-8');
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Find the .codragraph directory by walking up from startDir.
+ * Returns the path to .codragraph/ or null if not found.
+ */
+function findCodraGraphDir(startDir) {
+  let dir = startDir || process.cwd();
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, '.codragraph');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Extract search pattern from tool input.
+ */
+function extractPattern(toolName, toolInput) {
+  if (toolName === 'Grep') {
+    return toolInput.pattern || null;
+  }
+
+  if (toolName === 'Glob') {
+    const raw = toolInput.pattern || '';
+    const match = raw.match(/[*\/]([a-zA-Z][a-zA-Z0-9_-]{2,})/);
+    return match ? match[1] : null;
+  }
+
+  if (toolName === 'Bash') {
+    const cmd = toolInput.command || '';
+    if (!/\brg\b|\bgrep\b/.test(cmd)) return null;
+
+    const tokens = cmd.split(/\s+/);
+    let foundCmd = false;
+    let skipNext = false;
+    const flagsWithValues = new Set([
+      '-e',
+      '-f',
+      '-m',
+      '-A',
+      '-B',
+      '-C',
+      '-g',
+      '--glob',
+      '-t',
+      '--type',
+      '--include',
+      '--exclude',
+    ]);
+
+    for (const token of tokens) {
+      if (skipNext) {
+        skipNext = false;
+        continue;
+      }
+      if (!foundCmd) {
+        if (/\brg$|\bgrep$/.test(token)) foundCmd = true;
+        continue;
+      }
+      if (token.startsWith('-')) {
+        if (flagsWithValues.has(token)) skipNext = true;
+        continue;
+      }
+      const cleaned = token.replace(/['"]/g, '');
+      return cleaned.length >= 3 ? cleaned : null;
+    }
+    return null;
+  }
+
+  return null;
+}
+
+/**
+ * Resolve the codragraph CLI path.
+ * 1. Relative path (works when script is inside npm package)
+ * 2. require.resolve (works when codragraph is globally installed)
+ * 3. Fall back to npx (returns empty string)
+ */
+function resolveCliPath() {
+  let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');
+  if (!fs.existsSync(cliPath)) {
+    try {
+      cliPath = require.resolve('@codragraph/cli/cli/index');
+    } catch {
+      cliPath = '';
+    }
+  }
+  return cliPath;
+}
+
+/**
+ * Spawn a codragraph CLI command synchronously.
+ * Returns the stderr output (KuzuDB captures stdout at OS level).
+ */
+function runCodraGraphCli(cliPath, args, cwd, timeout) {
+  const isWin = process.platform === 'win32';
+  if (cliPath) {
+    return spawnSync(process.execPath, [cliPath, ...args], {
+      encoding: 'utf-8',
+      timeout,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  }
+  // On Windows, invoke npx.cmd directly (no shell needed)
+  return spawnSync(isWin ? 'npx.cmd' : 'npx', ['-y', '@codragraph/cli', ...args], {
+    encoding: 'utf-8',
+    timeout: timeout + 5000,
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+/**
+ * PreToolUse handler — augment searches with graph context.
+ */
+function handlePreToolUse(input) {
+  const cwd = input.cwd || process.cwd();
+  if (!path.isAbsolute(cwd)) return;
+  if (!findCodraGraphDir(cwd)) return;
+
+  const toolName = input.tool_name || '';
+  const toolInput = input.tool_input || {};
+
+  if (toolName !== 'Grep' && toolName !== 'Glob' && toolName !== 'Bash') return;
+
+  const pattern = extractPattern(toolName, toolInput);
+  if (!pattern || pattern.length < 3) return;
+
+  const cliPath = resolveCliPath();
+  let result = '';
+  try {
+    const child = runCodraGraphCli(cliPath, ['augment', '--', pattern], cwd, 7000);
+    if (!child.error && child.status === 0) {
+      result = child.stderr || '';
+    }
+  } catch {
+    /* graceful failure */
+  }
+
+  if (result && result.trim()) {
+    sendHookResponse('PreToolUse', result.trim());
+  }
+}
+
+/**
+ * Emit a PostToolUse hook response with additional context for the agent.
+ */
+function sendHookResponse(hookEventName, message) {
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName, additionalContext: message },
+    }),
+  );
+}
+
+/**
+ * PostToolUse handler — detect index staleness after git mutations.
+ *
+ * Instead of spawning a full `codragraph analyze` synchronously (which blocks
+ * the agent for up to 120s and risks KuzuDB corruption on timeout), we do a
+ * lightweight staleness check: compare `git rev-parse HEAD` against the
+ * lastCommit stored in `.codragraph/meta.json`. If they differ, notify the
+ * agent so it can decide when to reindex.
+ */
+function handlePostToolUse(input) {
+  const toolName = input.tool_name || '';
+  if (toolName !== 'Bash') return;
+
+  const command = (input.tool_input || {}).command || '';
+  if (!/\bgit\s+(commit|merge|rebase|cherry-pick|pull)(\s|$)/.test(command)) return;
+
+  // Only proceed if the command succeeded
+  const toolOutput = input.tool_output || {};
+  if (toolOutput.exit_code !== undefined && toolOutput.exit_code !== 0) return;
+
+  const cwd = input.cwd || process.cwd();
+  if (!path.isAbsolute(cwd)) return;
+  const gitNexusDir = findCodraGraphDir(cwd);
+  if (!gitNexusDir) return;
+
+  // Compare HEAD against last indexed commit — skip if unchanged
+  let currentHead = '';
+  try {
+    const headResult = spawnSync('git', ['rev-parse', 'HEAD'], {
+      encoding: 'utf-8',
+      timeout: 3000,
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    currentHead = (headResult.stdout || '').trim();
+  } catch {
+    return;
+  }
+
+  if (!currentHead) return;
+
+  let lastCommit = '';
+  let hadEmbeddings = false;
+  try {
+    const meta = JSON.parse(fs.readFileSync(path.join(gitNexusDir, 'meta.json'), 'utf-8'));
+    lastCommit = meta.lastCommit || '';
+    hadEmbeddings = meta.stats && meta.stats.embeddings > 0;
+  } catch {
+    /* no meta — treat as stale */
+  }
+
+  // If HEAD matches last indexed commit, no reindex needed
+  if (currentHead && currentHead === lastCommit) return;
+
+  const analyzeCmd = `npx codragraph analyze${hadEmbeddings ? ' --embeddings' : ''}`;
+  sendHookResponse(
+    'PostToolUse',
+    `CodraGraph index is stale (last indexed: ${lastCommit ? lastCommit.slice(0, 7) : 'never'}). ` +
+      `Run \`${analyzeCmd}\` to update the knowledge graph.`,
+  );
+}
+
+// Dispatch map for hook events
+const handlers = {
+  PreToolUse: handlePreToolUse,
+  PostToolUse: handlePostToolUse,
+};
+
+function main() {
+  try {
+    const input = readInput();
+    const handler = handlers[input.hook_event_name || ''];
+    if (handler) handler(input);
+  } catch (err) {
+    if (process.env.CODRAGRAPH_DEBUG) {
+      console.error('CodraGraph hook error:', (err.message || '').slice(0, 200));
+    }
+  }
+}
+
+main();

package/hooks/claude/pre-tool-use.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# CodraGraph PreToolUse hook for Claude Code
+# Intercepts Grep/Glob/Bash searches and augments with graph context.
+# Receives JSON on stdin with { tool_name, tool_input, cwd, ... }
+# Returns JSON with additionalContext for graph-enriched results.
+
+INPUT=$(cat)
+
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null)
+
+# Extract search pattern based on tool type
+PATTERN=""
+
+case "$TOOL_NAME" in
+  Grep)
+    PATTERN=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null)
+    ;;
+  Glob)
+    # Glob patterns are file paths, not search terms — extract meaningful part
+    RAW=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null)
+    # Strip glob syntax to get the meaningful name (e.g., "**/*.ts" → skip, "auth*.ts" → "auth")
+    PATTERN=$(echo "$RAW" | sed -n 's/.*[*\/]\([a-zA-Z][a-zA-Z0-9_-]*\).*/\1/p')
+    ;;
+  Bash)
+    CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+    # Only augment grep/rg commands
+    if echo "$CMD" | grep -qE '\brg\b|\bgrep\b'; then
+      # Extract pattern from rg/grep
+      if echo "$CMD" | grep -qE '\brg\b'; then
+        PATTERN=$(echo "$CMD" | sed -n "s/.*\brg\s\+\(--[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p")
+      elif echo "$CMD" | grep -qE '\bgrep\b'; then
+        PATTERN=$(echo "$CMD" | sed -n "s/.*\bgrep\s\+\(-[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p")
+      fi
+    fi
+    ;;
+  *)
+    # Not a search tool — skip
+    exit 0
+    ;;
+esac
+
+# Skip if pattern too short or empty
+if [ -z "$PATTERN" ] || [ ${#PATTERN} -lt 3 ]; then
+  exit 0
+fi
+
+# Check if we're in a CodraGraph-indexed repo
+dir="${CWD:-$PWD}"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.codragraph" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Run codragraph augment — must be fast (<500ms target)
+# augment writes to stderr (KuzuDB captures stdout at OS level), so capture stderr and discard stdout
+RESULT=$(cd "$CWD" && npx -y codragraph augment "$PATTERN" 2>&1 1>/dev/null)
+
+if [ -n "$RESULT" ]; then
+  ESCAPED=$(echo "$RESULT" | jq -Rs .)
+  jq -n --argjson ctx "$ESCAPED" '{
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: $ctx
+    }
+  }'
+else
+  exit 0
+fi

package/hooks/claude/session-start.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# CodraGraph SessionStart hook for Claude Code
+# Fires on session startup. Stdout is injected into Claude's context.
+# Checks if the current directory has a CodraGraph index.
+
+dir="$PWD"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.codragraph" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Inject CodraGraph context — this stdout goes directly into Claude's context
+cat << 'EOF'
+## CodraGraph Code Intelligence
+
+This codebase is indexed by CodraGraph, providing a knowledge graph with execution flows, relationships, and semantic search.
+
+**Available MCP Tools:**
+- `query` — Process-grouped code intelligence (execution flows related to a concept)
+- `context` — 360-degree symbol view (categorized refs, process participation)
+- `impact` — Blast radius analysis (what breaks if you change a symbol)
+- `detect_changes` — Git-diff impact analysis (what do your changes affect)
+- `rename` — Multi-file coordinated rename with confidence tags
+- `cypher` — Raw graph queries
+- `list_repos` — Discover indexed repos
+
+**Quick Start:** READ `codragraph://repo/{name}/context` for codebase overview, then use `query` to find execution flows.
+
+**Resources:** `codragraph://repo/{name}/context` (overview), `/processes` (execution flows), `/schema` (for Cypher)
+EOF
+
+exit 0

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@codragraph/cli",
+  "version": "1.6.2",
+  "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
+  "author": {
+    "name": "Anit Chaudhary",
+    "email": "getintouch.anit@gmail.com",
+    "url": "https://anit.upfyn.com"
+  },
+  "license": "Apache-2.0",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "code-intelligence",
+    "knowledge-graph",
+    "cursor",
+    "claude",
+    "codex",
+    "ai-agent",
+    "@codragraph/cli",
+    "static-analysis",
+    "codebase-indexing"
+  ],
+  "type": "module",
+  "exports": {
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./*.js": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "bin": {
+    "@codragraph/cli": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "hooks",
+    "scripts",
+    "skills",
+    "vendor"
+  ],
+  "scripts": {
+    "build": "node scripts/build.js",
+    "serve": "tsx src/cli/index.ts serve",
+    "dev": "tsx watch src/cli/index.ts",
+    "test": "vitest run",
+    "test:unit": "vitest run test/unit",
+    "test:integration": "vitest run test/integration",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "postinstall": "node scripts/patch-tree-sitter-swift.cjs && node scripts/build-tree-sitter-proto.cjs",
+    "prepare": "node scripts/build.js",
+    "prepack": "node scripts/build.js"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^4.1.0",
+    "@ladybugdb/core": "^0.15.2",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@codragraph/graphstore": "*",
+    "@scarf/scarf": "^1.4.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^14.0.3",
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "glob": "^13.0.6",
+    "graphology": "^0.26.0",
+    "graphology-indices": "^0.17.0",
+    "graphology-utils": "^2.3.0",
+    "ignore": "^7.0.5",
+    "js-yaml": "^4.1.1",
+    "jsonc-parser": "^3.3.1",
+    "lru-cache": "^11.0.0",
+    "mnemonist": "^0.40.3",
+    "onnxruntime-node": "^1.24.0",
+    "pandemonium": "^2.4.0",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-c": "0.23.2",
+    "tree-sitter-c-sharp": "0.23.1",
+    "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-go": "^0.23.0",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-javascript": "^0.23.0",
+    "tree-sitter-php": "^0.23.0",
+    "tree-sitter-python": "0.23.4",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-rust": "0.23.1",
+    "tree-sitter-typescript": "^0.23.2",
+    "uuid": "^14.0.0"
+  },
+  "optionalDependencies": {
+    "node-addon-api": "^8.0.0",
+    "node-gyp-build": "^4.8.0",
+    "tree-sitter-dart": "git+https://github.com/UserNobody14/tree-sitter-dart.git#80e23c07b64494f7e21090bb3450223ef0b192f4",
+    "tree-sitter-kotlin": "^0.3.8",
+    "tree-sitter-proto": "file:./vendor/tree-sitter-proto",
+    "tree-sitter-swift": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.6.0",
+    "@types/uuid": "^11.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@codragraph/shared": "file:../codragraph-shared",
+    "tsx": "^4.0.0",
+    "typescript": "^5.4.5",
+    "vitest": "^4.0.18"
+  },
+  "overrides": {
+    "@huggingface/transformers": {
+      "onnxruntime-node": "$onnxruntime-node"
+    },
+    "tree-sitter-c": "0.23.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/scripts/bench-scope-resolution.ts

@@ -0,0 +1,134 @@
+/**
+ * Synthetic benchmark for scope-resolution. Builds a large in-memory
+ * Python workspace and times runScopeResolution against it directly,
+ * isolating the resolution cost from parse / heritage / pipeline
+ * overhead.
+ *
+ * Usage: REGISTRY_PRIMARY_PYTHON=1 npx tsx scripts/bench-scope-resolution.ts
+ */
+process.env.REGISTRY_PRIMARY_PYTHON = '1';
+
+import { generateId } from '../src/lib/utils.js';
+import { createKnowledgeGraph } from '../src/core/graph/graph.js';
+import { runScopeResolution } from '../src/core/ingestion/scope-resolution/index.js';
+import { pythonScopeResolver } from '../src/core/ingestion/languages/python/scope-resolver.js';
+
+const N_CLASSES = Number(process.env.BENCH_CLASSES ?? '60');
+const N_USERS = Number(process.env.BENCH_USERS ?? '40');
+const ITERS = Number(process.env.BENCH_ITERS ?? '5');
+
+function buildWorkspace(): { path: string; content: string }[] {
+  const files: { path: string; content: string }[] = [];
+
+  // Build N_CLASSES "model" files, each defining a class with a few methods.
+  for (let i = 0; i < N_CLASSES; i++) {
+    const lines: string[] = [];
+    for (let j = 0; j < 5; j++) {
+      lines.push(`class Model${i}_${j}:`);
+      lines.push(`    name: str`);
+      lines.push(`    def save(self) -> bool:`);
+      lines.push(`        return True`);
+      lines.push(`    def update(self, name: str) -> "Model${i}_${j}":`);
+      lines.push(`        self.name = name`);
+      lines.push(`        return self`);
+      lines.push(`    def get_other(self) -> "Model${i}_${(j + 1) % 5}":`);
+      lines.push(`        return Model${i}_${(j + 1) % 5}()`);
+      lines.push('');
+    }
+    files.push({ path: `models/m${i}.py`, content: lines.join('\n') });
+  }
+
+  // Build N_USERS "user" files that import from a few model files
+  // and exercise the receiver-bound dispatcher heavily.
+  for (let u = 0; u < N_USERS; u++) {
+    const targets = [u % N_CLASSES, (u + 1) % N_CLASSES, (u + 2) % N_CLASSES];
+    const imports = targets
+      .map((t) => `from models.m${t} import Model${t}_0, Model${t}_1, Model${t}_2`)
+      .join('\n');
+    const calls: string[] = [];
+    for (let k = 0; k < 30; k++) {
+      const t = targets[k % 3]!;
+      const j = k % 3;
+      calls.push(`    m${k} = Model${t}_${j}()`);
+      calls.push(`    m${k}.save()`);
+      calls.push(`    m${k}.update("x").save()`);
+      calls.push(`    m${k}.get_other().save()`);
+    }
+    const content = `${imports}\n\ndef use_${u}() -> None:\n${calls.join('\n')}\n`;
+    files.push({ path: `app/u${u}.py`, content });
+  }
+
+  return files;
+}
+
+function buildGraph(files: { path: string; content: string }[]) {
+  const graph = createKnowledgeGraph();
+  // Pre-populate File / Class / Function nodes the resolver expects.
+  for (const f of files) {
+    const fileId = generateId('File', f.path);
+    graph.addNode({
+      id: fileId,
+      label: 'File',
+      properties: { name: f.path, filePath: f.path },
+    });
+
+    // Lightweight regex-extract class & def names so the lookup index
+    // has something to find. Real pipeline builds these via parse phase;
+    // for the bench this stand-in is enough to exercise the resolver.
+    const classRe = /^class (\w+)/gm;
+    const defRe = /^\s*def (\w+)/gm;
+    let m: RegExpExecArray | null;
+    while ((m = classRe.exec(f.content)) !== null) {
+      const name = m[1]!;
+      const id = generateId('Class', `${f.path}:${name}`);
+      graph.addNode({
+        id,
+        label: 'Class',
+        properties: { name, filePath: f.path, qualifiedName: name },
+      });
+    }
+    while ((m = defRe.exec(f.content)) !== null) {
+      const name = m[1]!;
+      const id = generateId('Function', `${f.path}:${name}`);
+      graph.addNode({
+        id,
+        label: 'Function',
+        properties: { name, filePath: f.path, qualifiedName: name },
+      });
+    }
+  }
+  return graph;
+}
+
+async function main() {
+  const files = buildWorkspace();
+  console.log(`bench: ${files.length} files (${N_CLASSES} models × 5 classes + ${N_USERS} users)`);
+  console.log(`       × ${ITERS} iterations\n`);
+
+  // Warmup
+  for (let i = 0; i < 2; i++) {
+    const graph = buildGraph(files);
+    runScopeResolution({ graph, files, onWarn: () => {} }, pythonScopeResolver);
+  }
+
+  const samples: number[] = [];
+  for (let i = 0; i < ITERS; i++) {
+    const graph = buildGraph(files);
+    const start = process.hrtime.bigint();
+    runScopeResolution({ graph, files, onWarn: () => {} }, pythonScopeResolver);
+    const end = process.hrtime.bigint();
+    const ms = Number(end - start) / 1_000_000;
+    samples.push(ms);
+    console.log(`  iter ${i + 1}: ${ms.toFixed(0)} ms`);
+  }
+
+  samples.sort((a, b) => a - b);
+  const median = samples[Math.floor(samples.length / 2)]!;
+  const min = samples[0]!;
+  console.log(`\nmin: ${min.toFixed(0)} ms · median: ${median.toFixed(0)} ms`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});