@lucern/sdk 0.2.0-alpha.5 → 0.2.0-alpha.7

package/src/facade/beliefs.ts

@@ -0,0 +1,83 @@
+import {
+  createBeliefsClientCore,
+  type BeliefsClientCoreConfig,
+} from "@/lucern/packages/client-core/src/beliefs";
+
+export type BeliefsFacadeConfig = BeliefsClientCoreConfig;
+
+export function createBeliefsFacade(config: BeliefsFacadeConfig = {}) {
+  const beliefsClient = createBeliefsClientCore(config);
+
+  return {
+    async create(
+      input: Parameters<typeof beliefsClient.create>[0],
+      idempotencyKey?: Parameters<typeof beliefsClient.create>[1]
+    ) {
+      return beliefsClient.create(input, idempotencyKey);
+    },
+
+    async get(id: string) {
+      return beliefsClient.get(id);
+    },
+
+    async list(query: Parameters<typeof beliefsClient.list>[0]) {
+      return beliefsClient.list(query);
+    },
+
+    async refine(
+      id: string,
+      input: Parameters<typeof beliefsClient.refine>[1],
+      idempotencyKey?: Parameters<typeof beliefsClient.refine>[2]
+    ) {
+      return beliefsClient.refine(id, input, idempotencyKey);
+    },
+
+    async fork(
+      id: string,
+      input: Parameters<typeof beliefsClient.fork>[1],
+      idempotencyKey?: Parameters<typeof beliefsClient.fork>[2]
+    ) {
+      return beliefsClient.fork(id, input, idempotencyKey);
+    },
+
+    async updateConfidence(
+      id: string,
+      input: Parameters<typeof beliefsClient.updateConfidence>[1],
+      idempotencyKey?: Parameters<typeof beliefsClient.updateConfidence>[2]
+    ) {
+      return beliefsClient.updateConfidence(id, input, idempotencyKey);
+    },
+
+    async archive(
+      id: string,
+      input?: Parameters<typeof beliefsClient.archive>[1],
+      idempotencyKey?: Parameters<typeof beliefsClient.archive>[2]
+    ) {
+      return beliefsClient.archive(id, input, idempotencyKey);
+    },
+
+    async lineage(id: string) {
+      return beliefsClient.lineage(id);
+    },
+
+    async confidenceHistory(id: string) {
+      return beliefsClient.confidenceHistory(id);
+    },
+
+    async createContract(
+      id: string,
+      input: Parameters<typeof beliefsClient.createContract>[1],
+      idempotencyKey?: Parameters<typeof beliefsClient.createContract>[2]
+    ) {
+      return beliefsClient.createContract(id, input, idempotencyKey);
+    },
+
+    async bisect(
+      id: string,
+      input: Parameters<typeof beliefsClient.bisect>[1],
+      idempotencyKey?: Parameters<typeof beliefsClient.bisect>[2]
+    ) {
+      return beliefsClient.bisect(id, input, idempotencyKey);
+    },
+  };
+}

package/src/facade/context.ts

@@ -0,0 +1,110 @@
+import type { CompileContextInput, PublicCompiledContext } from "../contextTypes";
+
+export type ContextClientRequest = {
+  path: "/api/platform/v1/context/compile";
+  method: "POST";
+  body: Record<string, unknown>;
+};
+
+export type ContextFacadeTransport = {
+  request<T>(request: ContextClientRequest): Promise<T>;
+};
+
+export type ContextFacadeConfig = {
+  transport: ContextFacadeTransport;
+};
+
+function cleanString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
+}
+
+function cleanNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function cleanBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function buildCompileContextRequest(
+  topicId: string,
+  input: CompileContextInput = {}
+): ContextClientRequest {
+  const payload: Record<string, unknown> = { topicId };
+
+  const query = cleanString(input.query);
+  if (query) {
+    payload.query = query;
+  }
+
+  const budget = cleanNumber(input.budget) ?? cleanNumber(input.tokenBudget);
+  if (budget !== undefined) {
+    payload.budget = budget;
+  }
+
+  const ranking = cleanString(input.ranking) ?? cleanString(input.rankingProfile);
+  if (ranking) {
+    payload.ranking = ranking;
+  }
+
+  const limit = cleanNumber(input.limit);
+  if (limit !== undefined) {
+    payload.limit = limit;
+  }
+
+  const maxDepth = cleanNumber(input.maxDepth);
+  if (maxDepth !== undefined) {
+    payload.maxDepth = maxDepth;
+  }
+
+  const includeEntities = cleanBoolean(input.includeEntities);
+  if (includeEntities !== undefined) {
+    payload.includeEntities = includeEntities;
+  }
+
+  const mode = cleanString(input.mode);
+  if (mode) {
+    payload.mode = mode;
+  }
+
+  const includeFailures = cleanBoolean(input.includeFailures);
+  if (includeFailures !== undefined) {
+    payload.includeFailures = includeFailures;
+  }
+
+  const worktreeId = cleanString(input.worktreeId);
+  if (worktreeId) {
+    payload.worktreeId = worktreeId;
+  }
+
+  const sessionId = cleanString(input.sessionId);
+  if (sessionId) {
+    payload.sessionId = sessionId;
+  }
+
+  if (
+    Array.isArray(input.packWeightOverrides) &&
+    input.packWeightOverrides.length > 0
+  ) {
+    payload.packWeightOverrides = input.packWeightOverrides;
+  }
+
+  return {
+    path: "/api/platform/v1/context/compile",
+    method: "POST",
+    body: payload,
+  };
+}
+
+export function createContextFacade(config: ContextFacadeConfig) {
+  return {
+    compile(topicId: string, input: CompileContextInput = {}) {
+      const request = buildCompileContextRequest(topicId, input);
+      return config.transport.request<PublicCompiledContext>(request);
+    },
+  };
+}
+
+export type { CompileContextInput, PublicCompiledContext };

package/src/facade/contradictions.ts

@@ -0,0 +1,29 @@
+import {
+  createContradictionsClient,
+  type ContradictionsClientCoreConfig,
+} from "@/lucern/packages/client-core/src/contradictions";
+
+export type ContradictionsFacadeConfig = ContradictionsClientCoreConfig;
+
+export function createContradictionsFacade(
+  config: ContradictionsFacadeConfig = {}
+) {
+  const contradictionsClient = createContradictionsClient(config);
+
+  return {
+    async flag(
+      input: Parameters<typeof contradictionsClient.flag>[0],
+      idempotencyKey?: Parameters<typeof contradictionsClient.flag>[1]
+    ) {
+      return contradictionsClient.flag(input, idempotencyKey);
+    },
+
+    async list(query: Parameters<typeof contradictionsClient.list>[0]) {
+      return contradictionsClient.list(query);
+    },
+
+    async get(id: string) {
+      return contradictionsClient.get(id);
+    },
+  };
+}

package/src/facade/edges.ts

@@ -0,0 +1,30 @@
+import {
+  createEdgesClient,
+  type EdgesClientCoreConfig,
+} from "@/lucern/packages/client-core/src/edges";
+
+export type EdgesFacadeConfig = EdgesClientCoreConfig;
+
+export function createEdgesFacade(config: EdgesFacadeConfig = {}) {
+  const edgesClient = createEdgesClient(config);
+
+  return {
+    async create(
+      input: Parameters<typeof edgesClient.create>[0],
+      idempotencyKey?: Parameters<typeof edgesClient.create>[1]
+    ) {
+      return edgesClient.create(input, idempotencyKey);
+    },
+
+    async list(query: Parameters<typeof edgesClient.list>[0]) {
+      return edgesClient.list(query);
+    },
+
+    async traverse(
+      input: Parameters<typeof edgesClient.traverse>[0],
+      idempotencyKey?: Parameters<typeof edgesClient.traverse>[1]
+    ) {
+      return edgesClient.traverse(input, idempotencyKey);
+    },
+  };
+}

package/src/facade/events.ts

@@ -0,0 +1,23 @@
+import {
+  createEventsClientCore,
+  type EventsClientCoreConfig,
+} from "@/lucern/packages/client-core/src/events";
+
+export type EventsFacadeConfig = EventsClientCoreConfig;
+
+export function createEventsFacade(config: EventsFacadeConfig = {}) {
+  const eventsClient = createEventsClientCore(config);
+
+  return {
+    async list(query: Parameters<typeof eventsClient.list>[0]) {
+      return eventsClient.list(query);
+    },
+
+    async replay(
+      input: Parameters<typeof eventsClient.replay>[0],
+      idempotencyKey?: Parameters<typeof eventsClient.replay>[1]
+    ) {
+      return eventsClient.replay(input, idempotencyKey);
+    },
+  };
+}

package/src/facade/evidence.ts

@@ -0,0 +1,41 @@
+import {
+  createEvidenceClient,
+  type EvidenceClientCoreConfig,
+} from "@/lucern/packages/client-core/src/evidence";
+
+export type EvidenceFacadeConfig = EvidenceClientCoreConfig;
+
+export function createEvidenceFacade(config: EvidenceFacadeConfig = {}) {
+  const evidenceClient = createEvidenceClient(config);
+
+  return {
+    async create(
+      input: Parameters<typeof evidenceClient.create>[0],
+      idempotencyKey?: Parameters<typeof evidenceClient.create>[1]
+    ) {
+      return evidenceClient.create(input, idempotencyKey);
+    },
+
+    async get(id: string) {
+      return evidenceClient.get(id);
+    },
+
+    async list(query: Parameters<typeof evidenceClient.list>[0]) {
+      return evidenceClient.list(query);
+    },
+
+    async link(
+      input: Parameters<typeof evidenceClient.link>[0],
+      idempotencyKey?: Parameters<typeof evidenceClient.link>[1]
+    ) {
+      return evidenceClient.link(input, idempotencyKey);
+    },
+
+    async search(
+      query: Parameters<typeof evidenceClient.search>[0],
+      idempotencyKey?: Parameters<typeof evidenceClient.search>[1]
+    ) {
+      return evidenceClient.search(query, idempotencyKey);
+    },
+  };
+}

package/src/facade/graph.ts

@@ -0,0 +1,38 @@
+import {
+  createGraphClient,
+  type GraphClientCoreConfig,
+} from "@/lucern/packages/client-core/src/graph";
+
+export type GraphFacadeConfig = GraphClientCoreConfig;
+
+export function createGraphFacade(config: GraphFacadeConfig = {}) {
+  const graphClient = createGraphClient(config);
+
+  return {
+    async neighborhood(
+      input: Parameters<typeof graphClient.neighborhood>[0]
+    ) {
+      return graphClient.neighborhood(input);
+    },
+
+    async traverse(input: Parameters<typeof graphClient.traverse>[0]) {
+      return graphClient.traverse(input);
+    },
+
+    async analyze(input: Parameters<typeof graphClient.analyze>[0]) {
+      return graphClient.analyze(input);
+    },
+
+    async bias(input: Parameters<typeof graphClient.bias>[0]) {
+      return graphClient.bias(input);
+    },
+
+    async gaps(input: Parameters<typeof graphClient.gaps>[0]) {
+      return graphClient.gaps(input);
+    },
+
+    async falsify(input: Parameters<typeof graphClient.falsify>[0]) {
+      return graphClient.falsify(input);
+    },
+  };
+}

package/src/facade/identity.ts

@@ -0,0 +1,16 @@
+import {
+  createIdentityWhoamiClient,
+  type IdentityClientCoreConfig,
+} from "@/lucern/packages/client-core/src/identity";
+
+export type IdentityFacadeConfig = IdentityClientCoreConfig;
+
+export function createIdentityFacade(config: IdentityFacadeConfig = {}) {
+  const identityClient = createIdentityWhoamiClient(config);
+
+  return {
+    async whoami() {
+      return identityClient.whoami();
+    },
+  };
+}

package/src/facade/ontologies.ts

@@ -0,0 +1,34 @@
+import {
+  createOntologiesClientCore,
+  type OntologiesClientCoreConfig,
+} from "@/lucern/packages/client-core/src/ontologies";
+
+export type OntologiesFacadeConfig = OntologiesClientCoreConfig;
+
+export function createOntologiesFacade(config: OntologiesFacadeConfig = {}) {
+  const ontologiesClient = createOntologiesClientCore(config);
+
+  return {
+    async get(id: string) {
+      return ontologiesClient.get(id);
+    },
+
+    async list(query: Parameters<typeof ontologiesClient.list>[0] = {}) {
+      return ontologiesClient.list(query);
+    },
+
+    async bind(
+      input: Parameters<typeof ontologiesClient.bind>[0],
+      idempotencyKey?: Parameters<typeof ontologiesClient.bind>[1]
+    ) {
+      return ontologiesClient.bind(input, idempotencyKey);
+    },
+
+    async match(
+      input: Parameters<typeof ontologiesClient.match>[0],
+      idempotencyKey?: Parameters<typeof ontologiesClient.match>[1]
+    ) {
+      return ontologiesClient.match(input, idempotencyKey);
+    },
+  };
+}

package/src/facade/questions.ts

@@ -0,0 +1,59 @@
+import {
+  createQuestionsClient,
+  type QuestionsClientCoreConfig,
+} from "@/lucern/packages/client-core/src/questions";
+
+export type QuestionsFacadeConfig = QuestionsClientCoreConfig;
+
+export function createQuestionsFacade(config: QuestionsFacadeConfig = {}) {
+  const questionsClient = createQuestionsClient(config);
+
+  return {
+    async create(
+      input: Parameters<typeof questionsClient.create>[0],
+      idempotencyKey?: Parameters<typeof questionsClient.create>[1]
+    ) {
+      return questionsClient.create(input, idempotencyKey);
+    },
+
+    async get(id: string) {
+      return questionsClient.get(id);
+    },
+
+    async list(query: Parameters<typeof questionsClient.list>[0]) {
+      return questionsClient.list(query);
+    },
+
+    async answer(
+      id: string,
+      input: Parameters<typeof questionsClient.answer>[1],
+      idempotencyKey?: Parameters<typeof questionsClient.answer>[2]
+    ) {
+      return questionsClient.answer(id, input, idempotencyKey);
+    },
+
+    async refine(
+      id: string,
+      input: Parameters<typeof questionsClient.refine>[1],
+      idempotencyKey?: Parameters<typeof questionsClient.refine>[2]
+    ) {
+      return questionsClient.refine(id, input, idempotencyKey);
+    },
+
+    async archive(
+      id: string,
+      input?: Parameters<typeof questionsClient.archive>[1],
+      idempotencyKey?: Parameters<typeof questionsClient.archive>[2]
+    ) {
+      return questionsClient.archive(id, input, idempotencyKey);
+    },
+
+    async updateStatus(
+      id: string,
+      input: Parameters<typeof questionsClient.updateStatus>[1],
+      idempotencyKey?: Parameters<typeof questionsClient.updateStatus>[2]
+    ) {
+      return questionsClient.updateStatus(id, input, idempotencyKey);
+    },
+  };
+}

package/src/facade/search.ts

@@ -0,0 +1,16 @@
+import {
+  createSearchClient,
+  type SearchClientCoreConfig,
+} from "@/lucern/packages/client-core/src/search";
+
+export type SearchFacadeConfig = SearchClientCoreConfig;
+
+export function createSearchFacade(config: SearchFacadeConfig = {}) {
+  const searchClient = createSearchClient(config);
+
+  return {
+    async query(input: Parameters<typeof searchClient.query>[0]) {
+      return searchClient.query(input);
+    },
+  };
+}

package/src/facade/tasks.ts

@@ -0,0 +1,37 @@
+import {
+  createTasksClientCore,
+  type TasksClientCoreConfig,
+} from "@/lucern/packages/client-core/src/tasks";
+
+export type TasksFacadeConfig = TasksClientCoreConfig;
+
+export function createTasksFacade(config: TasksFacadeConfig = {}) {
+  const tasksClient = createTasksClientCore(config);
+
+  return {
+    async create(
+      input: Parameters<typeof tasksClient.create>[0],
+      idempotencyKey?: Parameters<typeof tasksClient.create>[1]
+    ) {
+      return tasksClient.create(input, idempotencyKey);
+    },
+
+    async update(
+      input: Parameters<typeof tasksClient.update>[0],
+      idempotencyKey?: Parameters<typeof tasksClient.update>[1]
+    ) {
+      return tasksClient.update(input, idempotencyKey);
+    },
+
+    async complete(
+      input: Parameters<typeof tasksClient.complete>[0],
+      idempotencyKey?: Parameters<typeof tasksClient.complete>[1]
+    ) {
+      return tasksClient.complete(input, idempotencyKey);
+    },
+
+    async list(query: Parameters<typeof tasksClient.list>[0]) {
+      return tasksClient.list(query);
+    },
+  };
+}

package/src/facade/topics.ts

@@ -0,0 +1,42 @@
+import {
+  createTopicsClientCore,
+  type TopicsClientCoreConfig,
+} from "@/lucern/packages/client-core/src/topics";
+
+export type TopicsFacadeConfig = TopicsClientCoreConfig;
+
+export function createTopicsFacade(config: TopicsFacadeConfig = {}) {
+  const topicsClient = createTopicsClientCore(config);
+
+  return {
+    async create(
+      input: Parameters<typeof topicsClient.create>[0],
+      idempotencyKey?: Parameters<typeof topicsClient.create>[1]
+    ) {
+      return topicsClient.create(input, idempotencyKey);
+    },
+
+    async get(id: string) {
+      return topicsClient.get(id);
+    },
+
+    async list(query: Parameters<typeof topicsClient.list>[0] = {}) {
+      return topicsClient.list(query);
+    },
+
+    async update(
+      input: Parameters<typeof topicsClient.update>[0],
+      idempotencyKey?: Parameters<typeof topicsClient.update>[1]
+    ) {
+      return topicsClient.update(input, idempotencyKey);
+    },
+
+    async tree(input: Parameters<typeof topicsClient.tree>[0]) {
+      return topicsClient.tree(input);
+    },
+
+    async coverage(input: Parameters<typeof topicsClient.coverage>[0]) {
+      return topicsClient.coverage(input);
+    },
+  };
+}

package/src/facade/webhooks.ts

@@ -0,0 +1,58 @@
+import {
+  createWebhooksClientCore,
+  type WebhooksClientCoreConfig,
+} from "@/lucern/packages/client-core/src/webhooks";
+
+export type WebhooksFacadeConfig = WebhooksClientCoreConfig;
+
+export function createWebhooksFacade(config: WebhooksFacadeConfig = {}) {
+  const webhooksClient = createWebhooksClientCore(config);
+
+  return {
+    async create(
+      input: Parameters<typeof webhooksClient.create>[0],
+      idempotencyKey?: Parameters<typeof webhooksClient.create>[1]
+    ) {
+      return webhooksClient.create(input, idempotencyKey);
+    },
+
+    async list(query?: Parameters<typeof webhooksClient.list>[0]) {
+      return webhooksClient.list(query);
+    },
+
+    async get(id: string) {
+      return webhooksClient.get(id);
+    },
+
+    async update(
+      id: string,
+      input: Parameters<typeof webhooksClient.update>[1],
+      idempotencyKey?: Parameters<typeof webhooksClient.update>[2]
+    ) {
+      return webhooksClient.update(id, input, idempotencyKey);
+    },
+
+    async delete(id: string, idempotencyKey?: Parameters<typeof webhooksClient.delete>[1]) {
+      return webhooksClient.delete(id, idempotencyKey);
+    },
+
+    async test(
+      id: string,
+      input?: Parameters<typeof webhooksClient.test>[1],
+      idempotencyKey?: Parameters<typeof webhooksClient.test>[2]
+    ) {
+      return webhooksClient.test(id, input, idempotencyKey);
+    },
+
+    async deliveries(
+      id: string,
+      query?: Parameters<typeof webhooksClient.deliveries>[1]
+    ) {
+      return webhooksClient.deliveries(id, query);
+    },
+
+    async health(id: string) {
+      return webhooksClient.health(id);
+    },
+  };
+}

package/src/facade/worktrees.ts

@@ -0,0 +1,51 @@
+import {
+  createWorktreesClientCore,
+  type WorktreesClientCoreConfig,
+} from "@/lucern/packages/client-core/src/worktrees";
+
+export type WorktreesFacadeConfig = WorktreesClientCoreConfig;
+
+export function createWorktreesFacade(config: WorktreesFacadeConfig = {}) {
+  const worktreesClient = createWorktreesClientCore(config);
+
+  return {
+    async create(
+      input: Parameters<typeof worktreesClient.create>[0],
+      idempotencyKey?: Parameters<typeof worktreesClient.create>[1]
+    ) {
+      return worktreesClient.create(input, idempotencyKey);
+    },
+
+    async list(query: Parameters<typeof worktreesClient.list>[0]) {
+      return worktreesClient.list(query);
+    },
+
+    async activate(
+      input: Parameters<typeof worktreesClient.activate>[0],
+      idempotencyKey?: Parameters<typeof worktreesClient.activate>[1]
+    ) {
+      return worktreesClient.activate(input, idempotencyKey);
+    },
+
+    async update(
+      input: Parameters<typeof worktreesClient.update>[0],
+      idempotencyKey?: Parameters<typeof worktreesClient.update>[1]
+    ) {
+      return worktreesClient.update(input, idempotencyKey);
+    },
+
+    async merge(
+      input: Parameters<typeof worktreesClient.merge>[0],
+      idempotencyKey?: Parameters<typeof worktreesClient.merge>[1]
+    ) {
+      return worktreesClient.merge(input, idempotencyKey);
+    },
+
+    async updateTargets(
+      input: Parameters<typeof worktreesClient.updateTargets>[0],
+      idempotencyKey?: Parameters<typeof worktreesClient.updateTargets>[1]
+    ) {
+      return worktreesClient.updateTargets(input, idempotencyKey);
+    },
+  };
+}