kenaz 0.3.10 → 0.3.12

package/core/dev/scripts/probe/hippocampus-concurrency.js

@@ -1,247 +0,0 @@
-#!/usr/bin/env node
-// TASK_1924: hippocampus concurrency probe.
-//
-// Purpose: measure whether N concurrent hippocampus_episode_recall MCP calls
-// (which, before TASK_1924, ran synchronous rusqlite/KuzuDB work directly on
-// a tokio worker thread) starve the HTTP server's worker pool badly enough
-// to stall unrelated requests (/api/rust/health) that share the same
-// tauri::async_runtime.
-//
-// Method:
-//   1. Fire N concurrent JSON-RPC tools/call requests for
-//      hippocampus_episode_recall against POST /api/mcp.
-//   2. Concurrently poll GET /api/rust/health every POLL_INTERVAL_MS for the
-//      duration of the burst.
-//   3. Report health-poll latency p50/p95/max + failure count, and the
-//      episode_recall call latencies + failure count.
-//
-// Run BEFORE and AFTER the spawn_blocking fix and compare the health p95/max:
-// a healthy fix should keep health latency in the tens-of-ms range regardless
-// of concurrent hippocampus load; an unfixed handler will show health p95/max
-// climbing toward the burst duration (worker-starved).
-//
-// Usage:
-//   node dev/scripts/probe/hippocampus-concurrency.js [options]
-//
-// Options:
-//   --base-url <url>       Rust backend base URL (default: http://127.0.0.1:18080)
-//   --concurrency <n>      Number of concurrent episode_recall calls (default: 8)
-//   --project-path <path>  projectPath arg for the MCP tool call (default: cwd)
-//   --poll-interval <ms>   Health poll interval in ms (default: 200)
-//   --query <text>         query arg for episode_recall (default: "spawn_blocking")
-//   --limit <n>            limit arg for episode_recall (default: 10)
-//
-// Example:
-//   node dev/scripts/probe/hippocampus-concurrency.js --concurrency 8
-
-'use strict';
-
-const http = require('http');
-const { URL } = require('url');
-
-function parseArgs(argv) {
-  const opts = {
-    baseUrl: 'http://127.0.0.1:18080',
-    concurrency: 8,
-    projectPath: process.cwd(),
-    pollIntervalMs: 200,
-    query: 'spawn_blocking',
-    limit: 10,
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    const next = () => argv[++i];
-    switch (a) {
-      case '--base-url':
-        opts.baseUrl = next();
-        break;
-      case '--concurrency':
-        opts.concurrency = parseInt(next(), 10);
-        break;
-      case '--project-path':
-        opts.projectPath = next();
-        break;
-      case '--poll-interval':
-        opts.pollIntervalMs = parseInt(next(), 10);
-        break;
-      case '--query':
-        opts.query = next();
-        break;
-      case '--limit':
-        opts.limit = parseInt(next(), 10);
-        break;
-      default:
-        break;
-    }
-  }
-  return opts;
-}
-
-function httpRequest(urlStr, { method = 'GET', headers = {}, body } = {}, timeoutMs = 60000) {
-  return new Promise((resolve) => {
-    const url = new URL(urlStr);
-    const started = Date.now();
-    const req = http.request(
-      {
-        hostname: url.hostname,
-        port: url.port,
-        path: url.pathname + url.search,
-        method,
-        headers,
-        timeout: timeoutMs,
-      },
-      (res) => {
-        const chunks = [];
-        res.on('data', (c) => chunks.push(c));
-        res.on('end', () => {
-          resolve({
-            ok: res.statusCode >= 200 && res.statusCode < 300,
-            status: res.statusCode,
-            durationMs: Date.now() - started,
-            body: Buffer.concat(chunks).toString('utf8'),
-            error: null,
-          });
-        });
-      }
-    );
-    req.on('timeout', () => {
-      req.destroy();
-      resolve({ ok: false, status: 0, durationMs: Date.now() - started, body: '', error: 'timeout' });
-    });
-    req.on('error', (err) => {
-      resolve({ ok: false, status: 0, durationMs: Date.now() - started, body: '', error: String(err && err.message || err) });
-    });
-    if (body) req.write(body);
-    req.end();
-  });
-}
-
-async function callMcpTool(baseUrl, toolName, args, id) {
-  const payload = JSON.stringify({
-    jsonrpc: '2.0',
-    id,
-    method: 'tools/call',
-    params: { name: toolName, arguments: args },
-  });
-  const res = await httpRequest(`${baseUrl}/api/mcp`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(payload),
-    },
-    body: payload,
-  });
-  let rpcError = null;
-  let toolIsError = false;
-  if (res.ok) {
-    try {
-      const parsed = JSON.parse(res.body);
-      if (parsed.error) rpcError = parsed.error.message || JSON.stringify(parsed.error);
-      if (parsed.result && parsed.result.isError) toolIsError = true;
-    } catch (e) {
-      rpcError = `non-JSON response: ${e.message}`;
-    }
-  }
-  return {
-    ok: res.ok && !rpcError && !toolIsError,
-    status: res.status,
-    durationMs: res.durationMs,
-    error: res.error || rpcError || (toolIsError ? 'tool returned isError' : null),
-  };
-}
-
-function percentile(sortedArr, p) {
-  if (sortedArr.length === 0) return null;
-  const idx = Math.min(sortedArr.length - 1, Math.ceil((p / 100) * sortedArr.length) - 1);
-  return sortedArr[Math.max(0, idx)];
-}
-
-function summarize(label, samples, failures) {
-  const durations = samples.map((s) => s.durationMs).sort((a, b) => a - b);
-  const p50 = percentile(durations, 50);
-  const p95 = percentile(durations, 95);
-  const max = durations.length ? durations[durations.length - 1] : null;
-  const min = durations.length ? durations[0] : null;
-  console.log(`\n[${label}]`);
-  console.log(`  samples: ${samples.length}, failures: ${failures}`);
-  console.log(`  min=${min}ms  p50=${p50}ms  p95=${p95}ms  max=${max}ms`);
-  return { label, count: samples.length, failures, min, p50, p95, max };
-}
-
-async function main() {
-  const opts = parseArgs(process.argv.slice(2));
-  console.log('TASK_1924 hippocampus concurrency probe');
-  console.log(`  baseUrl=${opts.baseUrl} concurrency=${opts.concurrency} pollIntervalMs=${opts.pollIntervalMs}`);
-  console.log(`  projectPath=${opts.projectPath}`);
-
-  let polling = true;
-  const healthSamples = [];
-  let healthFailures = 0;
-
-  const pollLoop = (async () => {
-    while (polling) {
-      const t0 = Date.now();
-      const res = await httpRequest(`${opts.baseUrl}/api/rust/health`, {}, 10000);
-      if (!res.ok) healthFailures++;
-      healthSamples.push({ durationMs: res.durationMs, ok: res.ok, ts: t0 });
-      const elapsed = Date.now() - t0;
-      const sleep = Math.max(0, opts.pollIntervalMs - elapsed);
-      await new Promise((r) => setTimeout(r, sleep));
-    }
-  })();
-
-  const burstStart = Date.now();
-  const calls = Array.from({ length: opts.concurrency }, (_, i) =>
-    callMcpTool(
-      opts.baseUrl,
-      'hippocampus_episode_recall',
-      {
-        projectPath: opts.projectPath,
-        query: opts.query,
-        limit: opts.limit,
-      },
-      `probe-${i}`
-    )
-  );
-  const callResults = await Promise.all(calls);
-  const burstDurationMs = Date.now() - burstStart;
-
-  // Keep polling briefly after the burst to catch any lingering worker-starvation tail.
-  await new Promise((r) => setTimeout(r, Math.max(opts.pollIntervalMs * 3, 600)));
-  polling = false;
-  await pollLoop;
-
-  const callFailures = callResults.filter((r) => !r.ok).length;
-
-  console.log(`\nBurst wall-clock: ${burstDurationMs}ms for ${opts.concurrency} concurrent episode_recall calls`);
-  const callSummary = summarize('hippocampus_episode_recall calls', callResults, callFailures);
-  const healthSummary = summarize('/api/rust/health polls (during + shortly after burst)', healthSamples, healthFailures);
-
-  if (callFailures > 0) {
-    console.log('\nFailed episode_recall calls:');
-    callResults.forEach((r, i) => {
-      if (!r.ok) console.log(`  #${i}: status=${r.status} error=${r.error}`);
-    });
-  }
-
-  console.log('\nJSON summary:');
-  console.log(
-    JSON.stringify(
-      {
-        concurrency: opts.concurrency,
-        burstDurationMs,
-        calls: callSummary,
-        health: healthSummary,
-      },
-      null,
-      2
-    )
-  );
-
-  process.exit(callFailures > 0 || healthFailures > 0 ? 1 : 0);
-}
-
-main().catch((err) => {
-  console.error('Probe crashed:', err);
-  process.exit(2);
-});