@lucern/graph-sync 0.3.0-alpha.10

package/dist/neo4jQueries.js

@@ -0,0 +1,1327 @@
+import { v } from 'convex/values';
+import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
+import { componentsGeneric, actionGeneric } from 'convex/server';
+
+// src/neo4jQueries.ts
+componentsGeneric();
+var action = actionGeneric;
+
+// src/neo4jQueries.ts
+function toInt(value, defaultValue) {
+  if (value === void 0 || value === null) {
+    return defaultValue;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.floor(parsed) : defaultValue;
+}
+function isAllowedProxyUrl(urlString) {
+  try {
+    const url = new URL(urlString);
+    const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+    if (!isLocalhost && url.protocol !== "https:") {
+      return false;
+    }
+    if (url.username || url.password) {
+      return false;
+    }
+    const configuredHosts = (process.env.LUCERN_GRAPH_SYNC_ALLOWED_PROXY_HOSTS || "").split(",").map((host) => host.trim().toLowerCase()).filter(Boolean);
+    if (configuredHosts.length === 0) {
+      return true;
+    }
+    const hostname = url.hostname.toLowerCase();
+    return configuredHosts.some(
+      (host) => host.startsWith(".") ? hostname.endsWith(host) : hostname === host
+    );
+  } catch {
+    console.warn("[Neo4j Queries] Rejected malformed proxy URL", urlString);
+    return false;
+  }
+}
+function createNeo4jQueryTransportSuccess(data) {
+  return { success: true, data };
+}
+function createNeo4jQueryTransportFailure(error) {
+  return { success: false, error };
+}
+function resolveProxyBaseUrl(apiBaseUrl) {
+  const resolved = apiBaseUrl || process.env.LUCERN_GRAPH_SYNC_QUERY_BASE_URL || process.env.NEXT_PUBLIC_APP_URL;
+  const normalized = resolved?.trim();
+  return normalized ? normalized.replace(/\/+$/u, "") : null;
+}
+function buildProxyEndpoint(proxyBaseUrl) {
+  const endpoint = new URL(proxyBaseUrl);
+  if (!endpoint.pathname.endsWith("/api/neo4j-query")) {
+    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/u, "")}/api/neo4j-query`;
+  }
+  return endpoint.toString();
+}
+async function callNeo4jQuery(queryName, params, apiBaseUrl) {
+  const proxyUrl = resolveProxyBaseUrl(apiBaseUrl);
+  if (!proxyUrl) {
+    return createNeo4jQueryTransportFailure(
+      "Neo4j query proxy URL not configured"
+    );
+  }
+  if (!isAllowedProxyUrl(proxyUrl)) {
+    console.error(
+      "[Neo4j Queries] Blocked request to disallowed URL:",
+      proxyUrl
+    );
+    return createNeo4jQueryTransportFailure("Invalid proxy URL");
+  }
+  const syncSecret = process.env.NEO4J_SYNC_SECRET;
+  if (!syncSecret) {
+    console.error("[Neo4j Queries] NEO4J_SYNC_SECRET not configured");
+    return createNeo4jQueryTransportFailure(
+      "Neo4j sync secret not configured"
+    );
+  }
+  try {
+    const explicitTenant = typeof params.tenantId === "string" ? params.tenantId.trim() : "";
+    const scopedTopic = typeof params.topicId === "string" ? params.topicId.trim() : "";
+    const legacyProject = typeof params.projectId === "string" ? params.projectId.trim() : "";
+    const scopedTopicId = scopedTopic || legacyProject;
+    const projectTenant = scopedTopicId ? `project:${scopedTopicId}` : "";
+    const defaultTenant = process.env.LUCERN_DEFAULT_TENANT_ID?.trim() || "";
+    const tenantId = explicitTenant || projectTenant || defaultTenant;
+    if (!tenantId) {
+      return createNeo4jQueryTransportFailure(
+        "Missing required tenant context (tenantId or topicId)"
+      );
+    }
+    const scopedParams = { ...params, tenantId };
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${syncSecret}`
+    };
+    const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+    if (bypassSecret && apiBaseUrl) {
+      headers["x-vercel-protection-bypass"] = bypassSecret;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const response = await fetch(buildProxyEndpoint(proxyUrl), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ queryName, params: scopedParams }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const result = await response.json();
+      if (!response.ok) {
+        return createNeo4jQueryTransportFailure(result.error || "Query failed");
+      }
+      return createNeo4jQueryTransportSuccess(result.data || []);
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError instanceof Error && fetchError.name === "AbortError") {
+        console.warn("[Neo4j Queries] Request timed out for:", queryName);
+        return createNeo4jQueryTransportFailure("Query timed out (10s)");
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error("[Neo4j Queries] Error in callNeo4jQuery:", queryName, error);
+    return createNeo4jQueryTransportFailure(
+      error instanceof Error ? error.message : "Network error connecting to query proxy"
+    );
+  }
+}
+function withTopicScope(args, params) {
+  return args.topicId ? { ...params, topicId: args.topicId } : params;
+}
+var getNodeLineageGraph = action({
+  args: {
+    globalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "nodeLineage",
+      withTopicScope(args, {
+        globalId: args.globalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      console.error("[Neo4j] Lineage query failed:", result.error);
+      return { lineage: [], error: result.error };
+    }
+    const lineage = result.data?.[0]?.lineage || [];
+    return { lineage };
+  }
+});
+var getConnectedNodesGraph = action({
+  args: {
+    globalId: v.string(),
+    maxHops: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const maxHops = Math.min(toInt(args.maxHops, 2), 5);
+    const limit = toInt(args.limit, 50);
+    const result = await callNeo4jQuery(
+      "connectedNodes",
+      withTopicScope(args, {
+        globalId: args.globalId,
+        maxHops,
+        limit
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      console.error("[Neo4j] Connected nodes query failed:", result.error);
+      return { nodes: [], error: result.error };
+    }
+    return { nodes: result.data || [] };
+  }
+});
+var getThemeBeliefsGraph = action({
+  args: {
+    themeGlobalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("themeBeliefs", {
+      themeGlobalId: args.themeGlobalId
+    });
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return {
+      beliefs: result.data?.map((r) => r.belief) || []
+    };
+  }
+});
+var getBeliefEvidenceGraph = action({
+  args: {
+    beliefGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "beliefEvidence",
+      withTopicScope(args, {
+        beliefGlobalId: args.beliefGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { evidence: [], error: result.error };
+    }
+    return {
+      evidence: result.data?.map((r) => r.evidence) || []
+    };
+  }
+});
+var getCrossThemeBeliefs = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "crossThemeBeliefs",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return {
+      beliefs: result.data?.map((r) => r.belief) || []
+    };
+  }
+});
+var findPotentialContradictions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "potentialContradictions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 10)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { contradictions: [], error: result.error };
+    }
+    return {
+      contradictions: result.data?.map(
+        (r) => r.contradiction
+      ) || []
+    };
+  }
+});
+var getThemeSubgraph = action({
+  args: {
+    themeGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "themeSubgraph",
+      withTopicScope(args, {
+        themeGlobalId: args.themeGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { subgraph: null, error: result.error };
+    }
+    return {
+      subgraph: result.data?.[0]?.subgraph || null
+    };
+  }
+});
+var getEvidenceToBeliefPath = action({
+  args: {
+    evidenceGlobalId: v.string(),
+    beliefGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "evidenceToBeliefPath",
+      withTopicScope(args, {
+        evidenceGlobalId: args.evidenceGlobalId,
+        beliefGlobalId: args.beliefGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { path: null, error: result.error };
+    }
+    const pathResult = result.data?.[0];
+    if (!pathResult?.pathResult) {
+      return { path: null, error: "No path found between evidence and belief" };
+    }
+    return {
+      path: {
+        nodes: pathResult.pathResult.nodes || [],
+        relationships: pathResult.pathResult.relationships || [],
+        length: pathResult.pathResult.length || 0
+      }
+    };
+  }
+});
+var getThemeStats = action({
+  args: {
+    themeGlobalId: v.string()
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("themeStats", {
+      themeGlobalId: args.themeGlobalId
+    });
+    if (!result.success) {
+      return { stats: null, error: result.error };
+    }
+    return { stats: result.data?.[0]?.stats || null };
+  }
+});
+var getThemeValueChainCandidates = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "themeValueChainCandidates",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 100)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { candidates: [], error: result.error };
+    }
+    return {
+      candidates: result.data?.map((r) => r.candidate) || []
+    };
+  }
+});
+var getThemesImpactingCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("themesImpactingCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 20)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getCompaniesByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("companiesByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getQuestionsByValueChain = action({
+  args: {
+    valueChainName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("questionsByValueChain", {
+      valueChainName: args.valueChainName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getQuestionsByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("questionsByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getPeopleByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("peopleByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getPeopleByCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("peopleByCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getValueChainsByTheme = action({
+  args: {
+    themeName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("valueChainsByTheme", {
+      themeName: args.themeName,
+      limit: toInt(args.limit, 20)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getFunctionsByValueChain = action({
+  args: {
+    valueChainName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("functionsByValueChain", {
+      valueChainName: args.valueChainName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getBeliefsByCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("beliefsByCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 30)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getEvidenceByCompany = action({
+  args: {
+    companyName: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("evidenceByCompany", {
+      companyName: args.companyName,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var searchAllNodes = action({
+  args: {
+    searchText: v.string(),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("searchAllNodes", {
+      searchText: args.searchText,
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getNodeRelationships = action({
+  args: {
+    globalId: v.optional(v.string()),
+    searchText: v.optional(v.string()),
+    limit: v.optional(v.number())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery("nodeRelationships", {
+      globalId: args.globalId || "",
+      searchText: args.searchText || "",
+      limit: toInt(args.limit, 50)
+    });
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getGraphStats = action({
+  args: {},
+  returns: permissiveReturn,
+  handler: async () => {
+    const result = await callNeo4jQuery("graphStats", {});
+    if (!result.success) {
+      return { stats: [], error: result.error };
+    }
+    return { stats: result.data || [] };
+  }
+});
+var queryGraph = action({
+  args: {
+    queryType: v.union(
+      v.literal("themesImpactingCompany"),
+      v.literal("companiesByTheme"),
+      v.literal("questionsByValueChain"),
+      v.literal("questionsByTheme"),
+      v.literal("peopleByTheme"),
+      v.literal("peopleByCompany"),
+      v.literal("valueChainsByTheme"),
+      v.literal("functionsByValueChain"),
+      v.literal("beliefsByCompany"),
+      v.literal("evidenceByCompany"),
+      v.literal("searchAllNodes"),
+      v.literal("nodeRelationships"),
+      v.literal("graphStats")
+    ),
+    params: v.object({
+      companyName: v.optional(v.string()),
+      themeName: v.optional(v.string()),
+      valueChainName: v.optional(v.string()),
+      searchText: v.optional(v.string()),
+      globalId: v.optional(v.string()),
+      limit: v.optional(v.number())
+    }),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const limit = toInt(args.params.limit, 30);
+    const themeRequiredQueries = [
+      "questionsByTheme",
+      "peopleByTheme",
+      "companiesByTheme",
+      "valueChainsByTheme"
+    ];
+    const companyRequiredQueries = [
+      "themesImpactingCompany",
+      "peopleByCompany",
+      "beliefsByCompany",
+      "evidenceByCompany"
+    ];
+    const valueChainRequiredQueries = [
+      "questionsByValueChain",
+      "functionsByValueChain"
+    ];
+    if (themeRequiredQueries.includes(args.queryType) && !args.params.themeName) {
+      return {
+        results: [],
+        error: `Query type '${args.queryType}' requires 'themeName' parameter`
+      };
+    }
+    if (companyRequiredQueries.includes(args.queryType) && !args.params.companyName) {
+      return {
+        results: [],
+        error: `Query type '${args.queryType}' requires 'companyName' parameter`
+      };
+    }
+    if (valueChainRequiredQueries.includes(args.queryType) && !args.params.valueChainName) {
+      return {
+        results: [],
+        error: `Query type '${args.queryType}' requires 'valueChainName' parameter`
+      };
+    }
+    const result = await callNeo4jQuery(
+      args.queryType,
+      withTopicScope(args, {
+        ...args.params,
+        limit
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getHighPriorityQuestions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "highPriorityQuestions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { questions: [], error: result.error };
+    }
+    return { questions: result.data || [] };
+  }
+});
+var getEvidenceByMethodology = action({
+  args: {
+    methodology: v.string(),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "evidenceByMethodology",
+      withTopicScope(args, {
+        methodology: args.methodology,
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { evidence: [], error: result.error };
+    }
+    return { evidence: result.data || [] };
+  }
+});
+var getProprietaryEvidence = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "proprietaryEvidence",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { evidence: [], error: result.error };
+    }
+    return { evidence: result.data || [] };
+  }
+});
+var getBeliefsByEpistemicStatus = action({
+  args: {
+    epistemicStatus: v.string(),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "beliefsByEpistemicStatus",
+      withTopicScope(args, {
+        epistemicStatus: args.epistemicStatus,
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return { beliefs: result.data || [] };
+  }
+});
+var getChallengedBeliefs = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "challengedBeliefs",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { beliefs: [], error: result.error };
+    }
+    return { beliefs: result.data || [] };
+  }
+});
+var getPredictions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "predictions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { predictions: [], error: result.error };
+    }
+    return { predictions: result.data || [] };
+  }
+});
+var getCausalChains = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "causalChains",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { chains: [], error: result.error };
+    }
+    return { chains: result.data || [] };
+  }
+});
+var getNecessaryEvidence = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "necessaryEvidence",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getFalsificationQuestions = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "falsificationQuestions",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { questions: [], error: result.error };
+    }
+    return { questions: result.data || [] };
+  }
+});
+var getConfirmationBiasScore = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "confirmationBiasScore",
+      {
+        ...args.topicId ? { topicId: args.topicId } : {},
+        limit: toInt(args.limit, 30)
+      },
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getAnchoringBiasDetection = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "anchoringBiasDetection",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSourceConcentrationRisk = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "sourceConcentrationRisk",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getMinimumFalsificationSet = action({
+  args: {
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "minimumFalsificationSet",
+      withTopicScope(args, {}),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { result: null, error: result.error };
+    }
+    const data = result.data;
+    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
+  }
+});
+var getContradictionTensionMap = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "contradictionTensionMap",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getReasoningDepthScore = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "reasoningDepthScore",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getKnowledgeFrontier = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "knowledgeFrontier",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getBeliefHalfLife = action({
+  args: {
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "beliefHalfLife",
+      withTopicScope(args, {}),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { result: null, error: result.error };
+    }
+    const data = result.data;
+    return { result: Array.isArray(data) && data.length > 0 ? data[0] : null };
+  }
+});
+var getMeetingPrepBrief = action({
+  args: {
+    personGlobalId: v.string(),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "meetingPrepBrief",
+      withTopicScope(args, {
+        personGlobalId: args.personGlobalId
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { brief: null, error: result.error };
+    }
+    const data = result.data;
+    return { brief: Array.isArray(data) && data.length > 0 ? data[0] : null };
+  }
+});
+var getProprietarySignals = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "proprietarySignals",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getPortfolioConviction = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "portfolioConviction",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 50)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { portfolio: [], error: result.error };
+    }
+    return { portfolio: result.data || [] };
+  }
+});
+var getStaleThemes = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "staleThemes",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { themes: [], error: result.error };
+    }
+    return { themes: result.data || [] };
+  }
+});
+var getMissingQuestionDetection = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "missingQuestionDetection",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSurpriseDetection = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "surpriseDetection",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getNonConsensusBeliefs = action({
+  args: {
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "nonConsensusBeliefs",
+      withTopicScope(args, {
+        limit: toInt(args.limit, 30)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var EMBEDDING_DIMENSIONS = 1024;
+var VALID_INDEX_NAMES = /* @__PURE__ */ new Set([
+  "belief_embedding_index",
+  "question_embedding_index",
+  "evidence_embedding_index",
+  "theme_embedding_index",
+  "source_embedding_index",
+  "synthesis_embedding_index"
+]);
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var semanticSearch = action({
+  args: {
+    embedding: v.array(v.float64()),
+    indexName: v.optional(v.string()),
+    topK: v.optional(v.number()),
+    minScore: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    if (args.embedding.length !== EMBEDDING_DIMENSIONS) {
+      return {
+        results: [],
+        error: `Embedding must be ${EMBEDDING_DIMENSIONS} dimensions, got ${args.embedding.length}`
+      };
+    }
+    const indexName = args.indexName || "belief_embedding_index";
+    if (!VALID_INDEX_NAMES.has(indexName)) {
+      return { results: [], error: `Invalid index name: ${indexName}` };
+    }
+    const result = await callNeo4jQuery(
+      "semanticSearch",
+      {
+        embedding: args.embedding,
+        indexName,
+        topK: toInt(args.topK, 10),
+        minScore: clamp(args.minScore ?? 0.5, 0, 1)
+      },
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSemanticOrphans = action({
+  args: {
+    threshold: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "semanticOrphans",
+      withTopicScope(args, {
+        threshold: clamp(args.threshold ?? 0.4, 0, 1),
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSoftContradictions = action({
+  args: {
+    similarityThreshold: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "softContradictions",
+      withTopicScope(args, {
+        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var getSemanticBridges = action({
+  args: {
+    similarityThreshold: v.optional(v.number()),
+    limit: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    const result = await callNeo4jQuery(
+      "semanticBridges",
+      withTopicScope(args, {
+        similarityThreshold: clamp(args.similarityThreshold ?? 0.7, 0, 1),
+        limit: toInt(args.limit, 20)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+var graphAwareSearch = action({
+  args: {
+    embedding: v.array(v.float64()),
+    indexName: v.optional(v.string()),
+    topK: v.optional(v.number()),
+    minScore: v.optional(v.number()),
+    apiBaseUrl: v.optional(v.string()),
+    topicId: v.optional(v.string())
+  },
+  returns: permissiveReturn,
+  handler: async (_ctx, args) => {
+    if (args.embedding.length !== EMBEDDING_DIMENSIONS) {
+      return {
+        results: [],
+        error: `Embedding must be ${EMBEDDING_DIMENSIONS} dimensions, got ${args.embedding.length}`
+      };
+    }
+    const indexName = args.indexName || "belief_embedding_index";
+    if (!VALID_INDEX_NAMES.has(indexName)) {
+      return { results: [], error: `Invalid index name: ${indexName}` };
+    }
+    const result = await callNeo4jQuery(
+      "graphAwareSearch",
+      withTopicScope(args, {
+        embedding: args.embedding,
+        indexName,
+        topK: toInt(args.topK, 10),
+        minScore: clamp(args.minScore ?? 0.5, 0, 1)
+      }),
+      args.apiBaseUrl
+    );
+    if (!result.success) {
+      return { results: [], error: result.error };
+    }
+    return { results: result.data || [] };
+  }
+});
+
+export { findPotentialContradictions, getAnchoringBiasDetection, getBeliefEvidenceGraph, getBeliefHalfLife, getBeliefsByCompany, getBeliefsByEpistemicStatus, getCausalChains, getChallengedBeliefs, getCompaniesByTheme, getConfirmationBiasScore, getConnectedNodesGraph, getContradictionTensionMap, getCrossThemeBeliefs, getEvidenceByCompany, getEvidenceByMethodology, getEvidenceToBeliefPath, getFalsificationQuestions, getFunctionsByValueChain, getGraphStats, getHighPriorityQuestions, getKnowledgeFrontier, getMeetingPrepBrief, getMinimumFalsificationSet, getMissingQuestionDetection, getNecessaryEvidence, getNodeLineageGraph, getNodeRelationships, getNonConsensusBeliefs, getPeopleByCompany, getPeopleByTheme, getPortfolioConviction, getPredictions, getProprietaryEvidence, getProprietarySignals, getQuestionsByTheme, getQuestionsByValueChain, getReasoningDepthScore, getSemanticBridges, getSemanticOrphans, getSoftContradictions, getSourceConcentrationRisk, getStaleThemes, getSurpriseDetection, getThemeBeliefsGraph, getThemeStats, getThemeSubgraph, getThemeValueChainCandidates, getThemesImpactingCompany, getValueChainsByTheme, graphAwareSearch, queryGraph, searchAllNodes, semanticSearch };
+//# sourceMappingURL=neo4jQueries.js.map
+//# sourceMappingURL=neo4jQueries.js.map