@lucern/sdk 0.2.0-alpha.1

package/dist/lucern/packages/domain-context/src/context-pack-compiler.d.ts

@@ -0,0 +1,101 @@
+import { type ContextCompilationMode, type ContextPackV1, type PackWeightOverride } from "../../../contracts/src/context-pack.contract";
+import { resolveEffectiveWeights } from "../../../mcp-server/src/context-pack-policy";
+import { type ContextRankingProfile } from "../../../mcp-server/src/context-pack-schema";
+export type ContextPackTopicRow = {
+    _id: string;
+    name?: string;
+    parentTopicId?: string;
+    depth?: number;
+    status?: string;
+    updatedAt?: number;
+    createdAt?: number;
+    generatedAt?: number;
+};
+type ContextPackBeliefRow = {
+    _id: string;
+    canonicalText?: string;
+    confidence?: number;
+    beliefType?: string;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    updatedAt?: number;
+    createdAt?: number;
+};
+type ContextPackQuestionRow = {
+    _id: string;
+    canonicalText?: string;
+    status?: string;
+    metadata?: Record<string, unknown>;
+    updatedAt?: number;
+    createdAt?: number;
+};
+type ContextPackEvidenceRow = {
+    _id: string;
+    canonicalText?: string;
+    sourceUrl?: string;
+    metadata?: Record<string, unknown>;
+    updatedAt?: number;
+    createdAt?: number;
+};
+type ContextPackContradictionRow = {
+    _id?: string;
+    globalId?: string;
+    weight?: number;
+    context?: string;
+    description?: string;
+    summary?: string;
+    updatedAt?: number;
+    createdAt?: number;
+};
+type ContextPackEntityRow = {
+    _id: string;
+    nodeType?: string;
+    title?: string;
+    canonicalText?: string;
+    connectedBeliefCount?: number;
+    connectedEvidenceCount?: number;
+    metadata?: Record<string, unknown>;
+    updatedAt?: number;
+};
+type ContextPackFailureRow = {
+    _id: string;
+    canonicalText?: string;
+    metadata?: Record<string, unknown>;
+    updatedAt?: number;
+    createdAt?: number;
+};
+export type CompileContextPackPlan = {
+    topicId: string;
+    queryText?: string;
+    tokens: string[];
+    limit: number;
+    rankingProfile: ContextRankingProfile;
+    tokenBudget: number;
+    descendantDepth: number;
+    includeEntities: boolean;
+    compilationMode: ContextCompilationMode;
+    includeFailures: boolean;
+    worktreeId?: string;
+    sessionId?: string;
+    packWeightOverrides?: PackWeightOverride[];
+    effectiveWeights: ReturnType<typeof resolveEffectiveWeights>;
+    scopedTopicIds: string[];
+};
+export type CompileContextPackPlanInput = {
+    args: Record<string, unknown> | undefined;
+    topic: ContextPackTopicRow;
+    allTopics: ContextPackTopicRow[];
+};
+export type CompileContextPackSnapshot = {
+    topic: ContextPackTopicRow;
+    plan: CompileContextPackPlan;
+    beliefs: ContextPackBeliefRow[];
+    questions: ContextPackQuestionRow[];
+    evidence: ContextPackEvidenceRow[];
+    contradictions: ContextPackContradictionRow[];
+    entities: ContextPackEntityRow[];
+    failures?: ContextPackFailureRow[];
+};
+export declare function planContextPackCompilation(input: CompileContextPackPlanInput): CompileContextPackPlan;
+export declare function compileContextPackFromSnapshot(snapshot: CompileContextPackSnapshot): ContextPackV1;
+export {};

package/dist/lucern/packages/domain-context/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./compile";
+export * from "./context-pack-compiler";
+export * from "./ports";
+export * from "./public-types";

package/dist/lucern/packages/domain-context/src/ports.d.ts

@@ -0,0 +1,58 @@
+import type { ContextCompilationMode, ContextPackV1, ContextRankingProfile, PackWeightOverride } from "../../../contracts/src/context-pack.contract";
+export type CompileContextCommand = {
+    topicId?: string;
+    projectId?: string;
+    query?: string;
+    budget?: number;
+    ranking?: ContextRankingProfile;
+    limit?: number;
+    maxDepth?: number;
+    includeEntities?: boolean;
+    mode?: ContextCompilationMode;
+    includeFailures?: boolean;
+    worktreeId?: string;
+    sessionId?: string;
+    packWeightOverrides?: PackWeightOverride[];
+    /** @deprecated Use budget. */
+    tokenBudget?: number;
+    /** @deprecated Use ranking. */
+    rankingProfile?: ContextRankingProfile;
+    actorPrincipalId?: string;
+    policyTraceId?: string | null;
+    allowedTopicIds?: string[];
+};
+export type CompileContextPortInput = {
+    topicId: string;
+    projectId: string;
+    query?: string;
+    budget?: number;
+    ranking?: ContextRankingProfile;
+    limit?: number;
+    maxDepth?: number;
+    includeEntities?: boolean;
+    mode?: ContextCompilationMode;
+    includeFailures?: boolean;
+    worktreeId?: string;
+    sessionId?: string;
+    packWeightOverrides?: PackWeightOverride[];
+    allowedTopicIds: string[];
+};
+export type ContextCompilerPort = {
+    compile(input: CompileContextPortInput): Promise<ContextPackV1>;
+};
+export type ContextPolicyPort = {
+    filterReadableTopicIds(input: {
+        topicIds: string[];
+        actorPrincipalId: string;
+        traceId?: string | null;
+    }): Promise<string[]>;
+    listReadableTopicIds(input: {
+        actorPrincipalId: string;
+        traceId?: string | null;
+    }): Promise<string[]>;
+};
+export type CompileContextPorts = {
+    compiler: ContextCompilerPort;
+    policy?: ContextPolicyPort;
+    requireAuth?: boolean;
+};

package/dist/lucern/packages/domain-context/src/public-types.d.ts

@@ -0,0 +1 @@
+export type { PublicCompiledContext, PublicContextBelief, PublicContextContradiction, PublicContextEntity, PublicContextEvidence, PublicContextInjectionPolicy, PublicContextQuestion, } from "../../../contracts/src/context-pack.contract";

package/dist/lucern/packages/domain-edges/src/contradictions.d.ts

@@ -0,0 +1,59 @@
+type PublicSeverity = "low" | "medium" | "high" | "critical";
+type DefeatType = "rebuts" | "undercuts" | "undermines";
+export type ContradictionRecord = {
+    id: string;
+    contradictionId: string;
+    topicId?: string;
+    beliefA: string;
+    beliefB: string;
+    description: string;
+    severity: PublicSeverity;
+    status: string;
+    defeatType: DefeatType;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type ContradictionListResult = {
+    contradictions: ContradictionRecord[];
+    nextCursor: null;
+};
+export type FlagContradictionInput = {
+    beliefA: string;
+    beliefB: string;
+    description: string;
+    topicId: string;
+    severity?: string;
+    defeatType?: string;
+};
+export type ListContradictionsQuery = {
+    topicId: string;
+    status?: string;
+    limit?: number;
+    cursor?: string;
+};
+type PortSeverity = "critical" | "significant" | "minor";
+type FlagContradictionPortInput = {
+    beliefARawId: string;
+    beliefBRawId: string;
+    description: string;
+    topicId: string;
+    severity: PortSeverity;
+    publicSeverity: PublicSeverity;
+    defeatType: DefeatType;
+};
+export type ContradictionsPort = {
+    fetchBelief: (rawId: string) => Promise<unknown | null>;
+    flagContradiction: (input: FlagContradictionPortInput) => Promise<unknown>;
+    listByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    getById: (id: string) => Promise<unknown | null>;
+};
+export declare function flagContradiction(deps: ContradictionsPort, input: FlagContradictionInput): Promise<ContradictionRecord>;
+export declare function listContradictions(deps: ContradictionsPort, query: ListContradictionsQuery): Promise<ContradictionListResult>;
+export declare function getContradiction(deps: ContradictionsPort, input: {
+    id: string;
+}): Promise<ContradictionRecord>;
+export {};

package/dist/lucern/packages/domain-edges/src/edges.d.ts

@@ -0,0 +1,91 @@
+type EdgeDirection = "up" | "down" | "both";
+export type EdgeRecord = {
+    id: string;
+    edgeId: string;
+    globalId?: string;
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+    fromLayer?: string;
+    toLayer?: string;
+    isDuplicate?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type EdgeListResult = {
+    edges: EdgeRecord[];
+    nextCursor: null;
+};
+export type EdgeTraversalNode = {
+    id: string;
+    nodeId: string;
+    globalId?: string;
+    nodeType?: string;
+    text?: string;
+    confidence?: number;
+    depth?: number;
+    topicId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type EdgeTraversalResult = {
+    startNode: string;
+    direction: EdgeDirection;
+    maxDepth: number;
+    nodes: EdgeTraversalNode[];
+    edges: EdgeRecord[];
+    depth: number;
+};
+export type CreateEdgeInput = {
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+};
+export type ListEdgesQuery = {
+    sourceId: string;
+    edgeType?: string;
+    limit?: number;
+    cursor?: string;
+};
+export type TraverseEdgesInput = {
+    startNode: string;
+    direction?: string;
+    maxDepth?: number;
+    topicId?: string;
+};
+type EdgeCreatePortInput = {
+    sourceRawId: string;
+    targetRawId: string;
+    edgeType: string;
+    topicId?: string;
+    confidence?: number;
+    weight?: number;
+    context?: string;
+};
+type EdgeTraversePortInput = {
+    startNode: string;
+    direction: EdgeDirection;
+    maxDepth: number;
+    topicId?: string;
+};
+export type EdgePort = {
+    createEdge: (input: EdgeCreatePortInput) => Promise<unknown>;
+    listEdgesBySource: (args: {
+        sourceRawId: string;
+        edgeType?: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    traverseEdges: (input: EdgeTraversePortInput) => Promise<unknown>;
+};
+export declare function createEdge(deps: EdgePort, input: CreateEdgeInput): Promise<EdgeRecord>;
+export declare function listEdges(deps: EdgePort, query: ListEdgesQuery): Promise<EdgeListResult>;
+export declare function traverseEdges(deps: EdgePort, input: TraverseEdgesInput): Promise<EdgeTraversalResult>;
+export {};

package/dist/lucern/packages/domain-edges/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./edges";
+export * from "./contradictions";

package/dist/lucern/packages/domain-evidence/src/evidence.d.ts

@@ -0,0 +1,115 @@
+export type EvidenceTargetType = "belief" | "question";
+type EvidenceRelation = "supports" | "contradicts" | "neutral";
+export type EvidenceRecord = {
+    id: string;
+    nodeId: string;
+    evidenceId: string;
+    globalId?: string;
+    topicId?: string;
+    text: string;
+    title?: string;
+    kind?: string;
+    source?: string;
+    sourceType?: string;
+    externalSourceType?: string;
+    status?: string;
+    relation?: EvidenceRelation;
+    confidence?: number;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type EvidenceListResult = {
+    evidence: EvidenceRecord[];
+    nextCursor: null;
+};
+export type EvidenceSearchResult = {
+    evidenceId: string;
+    nodeId: string;
+    globalId?: string;
+    text: string;
+    source?: string;
+    kind?: string;
+    relevanceScore: number;
+};
+export type EvidenceSearchPage = {
+    results: EvidenceSearchResult[];
+    nextCursor: null;
+};
+export type LinkEvidenceResult = {
+    edgeId: string;
+    evidenceId: string;
+    targetId: string;
+    targetType: EvidenceTargetType;
+    weight: number;
+    beliefId?: string;
+    questionId?: string;
+};
+export type CreateEvidenceInput = {
+    topicId: string;
+    text: string;
+    source?: string;
+    targetId?: string;
+    targetType?: EvidenceTargetType;
+    weight?: number;
+    metadata?: Record<string, unknown>;
+    title?: string;
+    content?: string;
+    contentType?: string;
+    kind?: string;
+};
+export type ListEvidenceQuery = {
+    topicId?: string;
+    targetId?: string;
+    limit?: number;
+    cursor?: string;
+};
+export type SearchEvidenceQuery = {
+    q: string;
+    topicId?: string;
+    targetId?: string;
+    limit?: number;
+    cursor?: string;
+};
+type TargetRef = {
+    type: EvidenceTargetType;
+    rawId: string;
+};
+type EvidenceCreatePortInput = Omit<CreateEvidenceInput, "targetId"> & {
+    target?: TargetRef;
+    weight: number;
+};
+type EvidenceLinkPortInput = {
+    evidenceRawId: string;
+    targetRawId: string;
+    weight: number;
+    rationale?: string;
+};
+export type EvidencePort = {
+    fetchEvidence: (rawId: string) => Promise<unknown | null>;
+    listEvidenceByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listEvidenceForBelief: (rawBeliefId: string) => Promise<unknown[]>;
+    listEvidenceForQuestion: (rawQuestionId: string) => Promise<unknown[]>;
+    createEvidence: (input: EvidenceCreatePortInput) => Promise<unknown>;
+    linkEvidenceToBelief: (input: EvidenceLinkPortInput) => Promise<unknown>;
+    linkEvidenceToQuestion: (input: EvidenceLinkPortInput) => Promise<unknown>;
+};
+export declare function getEvidence(deps: EvidencePort, input: {
+    id: string;
+}): Promise<EvidenceRecord>;
+export declare function listEvidence(deps: EvidencePort, query: ListEvidenceQuery): Promise<EvidenceListResult>;
+export declare function searchEvidence(deps: EvidencePort, query: SearchEvidenceQuery): Promise<EvidenceSearchPage>;
+export declare function createEvidence(deps: EvidencePort, input: CreateEvidenceInput): Promise<EvidenceRecord>;
+export declare function linkEvidence(deps: EvidencePort, input: {
+    evidenceId: string;
+    targetId: string;
+    targetType?: string;
+    weight?: number;
+    rationale?: string;
+}): Promise<LinkEvidenceResult>;
+export {};

package/dist/lucern/packages/domain-evidence/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./evidence";

package/dist/lucern/packages/domain-graph/src/graph.d.ts

@@ -0,0 +1,150 @@
+type GraphDirection = "up" | "down" | "both";
+type GraphNodeRecord = Record<string, unknown>;
+type GraphEdgeRecord = Record<string, unknown>;
+type GraphBeliefGapRecord = {
+    beliefId: string;
+    text: string;
+    confidence: number | null;
+    suggestedQuestions: string[];
+};
+export type GraphNeighborhoodInput = {
+    globalId?: string;
+    globalIds?: string[];
+    maxDepth?: number;
+};
+export type GraphNeighborhoodResult = {
+    nodes: GraphNodeRecord[];
+    edges: GraphEdgeRecord[];
+    depth: number;
+};
+export type GraphTraverseInput = {
+    startNode: string;
+    direction?: string;
+    maxDepth?: number;
+    topicId?: string;
+};
+export type GraphTraverseResult = {
+    startNode: string;
+    direction: GraphDirection;
+    maxDepth: number;
+    nodes: GraphNodeRecord[];
+    edges: GraphEdgeRecord[];
+    depth: number;
+    topicId?: string;
+};
+export type GraphAnalyzeInput = {
+    topicId: string;
+    metric?: string;
+    limit?: number;
+};
+export type GraphAnalyzeResult = {
+    topicId: string;
+    metric: string;
+    payload: Record<string, unknown>;
+};
+export type GraphBiasInput = {
+    topicId: string;
+    threshold?: number;
+    limit?: number;
+};
+export type GraphBiasBelief = {
+    nodeId: string;
+    biasScore: number;
+    riskLevel: string;
+    supportingCount: number;
+    challengingCount: number;
+};
+export type GraphBiasResult = {
+    topicId: string;
+    metric: "confirmation_bias";
+    threshold: number;
+    beliefs: GraphBiasBelief[];
+    payload: Record<string, unknown>;
+};
+export type GraphGapsInput = {
+    topicId: string;
+    minConfidence?: number;
+};
+export type GraphGapsResult = {
+    topicId: string;
+    gaps: GraphBeliefGapRecord[];
+    totalGaps: number;
+};
+type GraphBeliefRecord = {
+    beliefId?: string;
+    nodeId?: string;
+    topicId?: string;
+    text?: string;
+    canonicalText?: string;
+    confidence?: number | null;
+};
+type GraphQuestionRecord = {
+    questionId?: string;
+    nodeId?: string;
+    linkedBeliefId?: string;
+};
+type GraphTestingEdgeRecord = {
+    fromNodeId?: string;
+    toNodeId?: string;
+    edgeType?: string;
+};
+export type GraphFalsifyInput = {
+    topicId?: string;
+    beliefId?: string;
+    beliefIds?: string[];
+    minConfidence?: number;
+};
+export type GraphFalsificationQuestion = {
+    questionText: string;
+    falsificationPotential: number;
+    targetBeliefId: string;
+    targetBeliefText: string;
+};
+export type GraphFalsifyResult = {
+    topicId: string;
+    questions: GraphFalsificationQuestion[];
+};
+export type GraphPort = {
+    neighborhood: (input: {
+        globalIds: string[];
+        maxDepth: number;
+    }) => Promise<unknown>;
+    traverse: (input: {
+        startNode: string;
+        direction: GraphDirection;
+        maxDepth: number;
+        topicId?: string;
+    }) => Promise<unknown>;
+    analyze: (input: {
+        topicId: string;
+        metric: string;
+        limit?: number;
+    }) => Promise<unknown>;
+    bias: (input: {
+        topicId: string;
+        threshold: number;
+        limit?: number;
+    }) => Promise<unknown>;
+    listBeliefs: (input: {
+        topicId: string;
+        minConfidence?: number;
+        limit?: number;
+    }) => Promise<GraphBeliefRecord[]>;
+    fetchBelief: (input: {
+        beliefId: string;
+    }) => Promise<GraphBeliefRecord | null>;
+    listQuestions: (input: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<GraphQuestionRecord[]>;
+    listTestingEdges: (input: {
+        topicId: string;
+    }) => Promise<GraphTestingEdgeRecord[]>;
+};
+export declare function graphNeighborhood(deps: GraphPort, input: GraphNeighborhoodInput): Promise<GraphNeighborhoodResult>;
+export declare function graphTraverse(deps: GraphPort, input: GraphTraverseInput): Promise<GraphTraverseResult>;
+export declare function graphAnalyze(deps: GraphPort, input: GraphAnalyzeInput): Promise<GraphAnalyzeResult>;
+export declare function graphBias(deps: GraphPort, input: GraphBiasInput): Promise<GraphBiasResult>;
+export declare function graphGaps(deps: GraphPort, input: GraphGapsInput): Promise<GraphGapsResult>;
+export declare function graphFalsify(deps: GraphPort, input: GraphFalsifyInput): Promise<GraphFalsifyResult>;
+export {};

package/dist/lucern/packages/domain-identity/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./whoami";

package/dist/lucern/packages/domain-identity/src/whoami.d.ts

@@ -0,0 +1,13 @@
+export type IdentitySummary = {
+    principalId: string;
+    principalType: string;
+    tenantId?: string;
+    workspaceId?: string;
+    scopes?: string[];
+    roles?: string[];
+};
+export type WhoamiPort = {
+    resolveIdentitySummary: (() => IdentitySummary) | (() => Promise<IdentitySummary>);
+};
+export declare function normalizeIdentitySummary(value: IdentitySummary): IdentitySummary;
+export declare function whoami(deps: WhoamiPort): Promise<IdentitySummary>;