@askexenow/exe-os 0.9.65 → 0.9.67

package/dist/bin/graph-layer-benchmark.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+// src/bin/graph-layer-benchmark.ts
+import { Client } from "pg";
+function now() {
+  return Date.now();
+}
+function sqlString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+async function timed(layer, check, fn) {
+  const start = now();
+  try {
+    const detail = await fn();
+    return { layer, check, ok: true, ms: now() - start, detail };
+  } catch (err) {
+    return { layer, check, ok: false, ms: now() - start, detail: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function withPg(url, fn) {
+  const client = new Client({ connectionString: url });
+  await client.connect();
+  try {
+    return await fn(client);
+  } finally {
+    await client.end();
+  }
+}
+async function canonicalBench(url) {
+  return withPg(url, async (client) => {
+    const rows = [];
+    rows.push(await timed("postgres-canonical", "ontology-counts", async () => {
+      const r = await client.query(`select
+        (select count(*) from memory.agent_events) as events,
+        (select count(*) from memory.agent_goals) as goals,
+        (select count(*) from memory.relationships) as relationships`);
+      return JSON.stringify(r.rows[0]);
+    }));
+    rows.push(await timed("postgres-canonical", "session-timeline", async () => {
+      const r = await client.query(`select id, event_type, occurred_at from memory.agent_events order by occurred_at desc limit 50`);
+      return `${r.rowCount ?? 0} latest events`;
+    }));
+    rows.push(await timed("postgres-canonical", "goal-evidence-hop", async () => {
+      const r = await client.query(`select g.id, g.statement, count(l.id)::int as links
+        from memory.agent_goals g left join memory.agent_goal_links l on l.goal_id = g.id
+        group by g.id, g.statement order by links desc limit 20`);
+      return `${r.rowCount ?? 0} goals with evidence links`;
+    }));
+    rows.push(await timed("postgres-canonical", "recursive-relationship-hop", async () => {
+      const r = await client.query(`with recursive walk(depth, source_entity_id, target_entity_id, path) as (
+          select 1, source_entity_id, target_entity_id, array[source_entity_id, target_entity_id]
+          from (select source_entity_id, target_entity_id from memory.relationships limit 25) seed
+        union all
+          select w.depth + 1, r.source_entity_id, r.target_entity_id, w.path || r.target_entity_id
+          from walk w join memory.relationships r on r.source_entity_id = w.target_entity_id
+          where w.depth < 3 and not r.target_entity_id = any(w.path)
+        ) select count(*)::int as paths from walk`);
+      return `${r.rows[0]?.paths ?? 0} paths depth<=3`;
+    }));
+    return rows;
+  });
+}
+async function ageBench(url) {
+  return withPg(url, async (client) => {
+    const rows = [];
+    const graph = process.env.AGE_GRAPH_NAME || "exe_ontology";
+    rows.push(await timed("apache-age", "extension-available", async () => {
+      const r = await client.query(`select installed_version from pg_available_extensions where name = 'age'`);
+      return r.rows[0]?.installed_version ? `available ${r.rows[0].installed_version}` : "not available";
+    }));
+    rows.push(await timed("apache-age", "extension-installed", async () => {
+      const r = await client.query(`select extversion from pg_extension where extname = 'age'`);
+      if (!r.rows[0]) throw new Error("age extension not installed in this database");
+      return `installed ${r.rows[0].extversion}`;
+    }));
+    rows.push(await timed("apache-age", "cypher-smoke", async () => {
+      await client.query(`LOAD 'age'`);
+      await client.query(`SET search_path = ag_catalog, "$user", public`);
+      const r = await client.query(`SELECT * FROM cypher(${sqlString(graph)}, $$ MATCH (n) RETURN count(n) $$) AS (count agtype)`);
+      return `${r.rowCount ?? 0} cypher rows`;
+    }));
+    return rows;
+  });
+}
+async function main() {
+  const url = process.env.DATABASE_URL || process.env.EXED_DATABASE_URL;
+  const ageUrl = process.env.AGE_DATABASE_URL || url;
+  const agensUrl = process.env.AGENSGRAPH_DATABASE_URL;
+  const results = [];
+  if (!url) throw new Error("DATABASE_URL or EXED_DATABASE_URL is required");
+  results.push(...await canonicalBench(url));
+  if (ageUrl) results.push(...await ageBench(ageUrl));
+  if (agensUrl) {
+    results.push(await timed("agensgraph", "connect-and-count", async () => withPg(agensUrl, async (client) => {
+      const r = await client.query(`select count(*)::int as nodes from ag_graph limit 1`);
+      return JSON.stringify(r.rows[0] ?? {});
+    })));
+  } else {
+    results.push({ layer: "agensgraph", check: "configured", ok: false, ms: 0, detail: "AGENSGRAPH_DATABASE_URL not set" });
+  }
+  console.log(JSON.stringify({ generated_at: (/* @__PURE__ */ new Date()).toISOString(), results }, null, 2));
+  const failedRequired = results.filter((r) => r.layer === "postgres-canonical" && !r.ok);
+  process.exit(failedRequired.length ? 1 : 0);
+}
+main().catch((err) => {
+  process.stderr.write(`[graph-layer-benchmark] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});