@lucern/sdk 0.2.0-alpha.13 → 0.2.0-alpha.3

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>;

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

@@ -0,0 +1,123 @@
+type OntologyTier = "platform" | "pack" | "tenant";
+type OntologyStatus = "draft" | "active" | "deprecated" | "archived";
+type OntologyVersionStatus = "draft" | "published" | "deprecated";
+export type OntologyEntitySubtype = {
+    value: string;
+    label: string;
+    description?: string;
+};
+export type OntologyEntityType = {
+    value: string;
+    label: string;
+    description?: string;
+    schema?: unknown;
+    subtypes?: OntologyEntitySubtype[];
+};
+export type OntologyEdgeType = {
+    value: string;
+    label: string;
+    description?: string;
+    sourceTypes?: string[];
+    targetTypes?: string[];
+    constraintSeverity?: "warn" | "info";
+};
+export type OntologyPublishedVersion = {
+    id: string;
+    version: string;
+    status: OntologyVersionStatus;
+    entityTypes: OntologyEntityType[];
+    edgeTypes: OntologyEdgeType[];
+    releaseNotes?: string;
+    publishedAt?: number;
+    publishedBy?: string;
+};
+export type OntologyRecord = {
+    id: string;
+    ontologyId: string;
+    ontologyKey: string;
+    name: string;
+    description?: string;
+    tier?: OntologyTier;
+    status?: OntologyStatus;
+    tenantId?: string;
+    parentOntologyId?: string;
+    createdBy?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    publishedVersion: OntologyPublishedVersion | null;
+};
+export type OntologyListQuery = {
+    tenantId?: string;
+    tier?: OntologyTier | string;
+    status?: OntologyStatus | string;
+};
+export type OntologyListResult = {
+    ontologies: OntologyRecord[];
+    total: number;
+};
+export type GetOntologyInput = {
+    id?: string;
+    ontologyKey?: string;
+    tenantId?: string;
+};
+export type BindOntologyInput = {
+    ontologyId: string;
+    topicId: string;
+};
+export type OntologyBindingResult = {
+    applied: true;
+    source: "direct";
+    ontologyId: string;
+    ontologyKey: string;
+    ontologyName: string;
+    topicId: string;
+    topicName?: string;
+    updatedAt?: number;
+};
+export type OntologyTypeMatch = {
+    entityType: string;
+    label: string;
+    score: number;
+    reason: string;
+};
+export type OntologyMatchInput = {
+    text: string;
+    topicId?: string;
+    ontologyId?: string;
+    minScore?: number;
+    limit?: number;
+};
+export type OntologyMatchResult = {
+    text: string;
+    matchCount: number;
+    matches: OntologyTypeMatch[];
+    ontologyId?: string;
+    message?: string;
+};
+export type OntologiesPort = {
+    fetchOntology: (rawId: string) => Promise<unknown | null>;
+    fetchOntologyByKey?: (ontologyKey: string, tenantId?: string) => Promise<unknown | null>;
+    listOntologies: (query: {
+        tenantId?: string;
+        tier?: OntologyTier;
+        status?: OntologyStatus;
+    }) => Promise<unknown[]>;
+    fetchPublishedVersion: (ontologyRawId: string) => Promise<unknown | null>;
+    bindOntologyToTopic: (args: {
+        ontologyRawId: string;
+        topicRawId: string;
+    }) => Promise<unknown>;
+    fetchTopic: (topicRawId: string) => Promise<unknown | null>;
+    resolveMatchVocabulary: (input: {
+        ontologyRawId?: string;
+        topicRawId?: string;
+    }) => Promise<{
+        ontologyRawId?: string;
+        entityTypes: OntologyEntityType[];
+    } | null>;
+};
+export declare function listOntologies(deps: OntologiesPort, query?: OntologyListQuery): Promise<OntologyListResult>;
+export declare function getOntology(deps: OntologiesPort, input: GetOntologyInput): Promise<OntologyRecord>;
+export declare function bindOntology(deps: OntologiesPort, input: BindOntologyInput): Promise<OntologyBindingResult>;
+export declare function matchOntology(deps: OntologiesPort, input: OntologyMatchInput): Promise<OntologyMatchResult>;
+export {};

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

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

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

@@ -0,0 +1,147 @@
+type QuestionStatus = "open" | "researching" | "answered" | "parked" | "closed";
+type QuestionPriority = "low" | "medium" | "high" | "urgent";
+type AnswerConfidence = "weak" | "medium" | "strong";
+export type QuestionRecord = {
+    id: string;
+    nodeId: string;
+    questionId: string;
+    globalId?: string;
+    topicId?: string;
+    text: string;
+    status: QuestionStatus;
+    priority: QuestionPriority;
+    category?: string;
+    linkedBeliefId?: string;
+    linkedWorktreeId?: string;
+    answer?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type QuestionListResult = {
+    questions: QuestionRecord[];
+    nextCursor: null;
+};
+export type QuestionAnswerResult = {
+    questionId: string;
+    answerId: string;
+    status: "answered";
+};
+export type QuestionArchiveResult = QuestionRecord & {
+    previousStatus: string;
+    newStatus: "archived";
+};
+export type CreateQuestionInput = {
+    topicId: string;
+    text: string;
+    priority?: string;
+    linkedBeliefId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type ListQuestionsQuery = {
+    topicId?: string;
+    status?: string;
+    priority?: string;
+    worktreeId?: string;
+    limit?: number;
+    cursor?: string;
+};
+type QuestionCreatePortInput = {
+    topicId: string;
+    text: string;
+    priority?: QuestionPriority;
+    linkedBeliefRawId?: string;
+    metadata?: Record<string, unknown>;
+};
+type QuestionRefinePortInput = {
+    questionRawId: string;
+    text: string;
+    rationale?: string;
+};
+type QuestionStatusPortInput = {
+    questionRawId: string;
+    status: QuestionStatus;
+    rationale?: string;
+};
+type QuestionAnswerPortInput = {
+    questionRawId: string;
+    topicId: string;
+    text: string;
+    confidence?: AnswerConfidence;
+    evidenceRawIds?: string[];
+    rationale?: string;
+};
+export type QuestionsPort = {
+    fetchQuestion: (rawId: string) => Promise<unknown | null>;
+    listQuestionsByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    createQuestion: (input: QuestionCreatePortInput) => Promise<unknown>;
+    refineQuestion: (input: QuestionRefinePortInput) => Promise<unknown>;
+    updateQuestionStatus: (input: QuestionStatusPortInput) => Promise<unknown>;
+    createAnswer: (input: QuestionAnswerPortInput) => Promise<unknown>;
+};
+export declare function createQuestion(deps: QuestionsPort, input: CreateQuestionInput): Promise<QuestionRecord>;
+export declare function getQuestion(deps: QuestionsPort, input: {
+    id: string;
+}): Promise<QuestionRecord>;
+export declare function listQuestions(deps: QuestionsPort, query: ListQuestionsQuery): Promise<QuestionListResult>;
+export declare function refineQuestion(deps: QuestionsPort, input: {
+    id: string;
+    text: string;
+    rationale?: string;
+}): Promise<{
+    previousText: string;
+    updatedText: string;
+    id: string;
+    nodeId: string;
+    questionId: string;
+    globalId?: string;
+    topicId?: string;
+    text: string;
+    status: QuestionStatus;
+    priority: QuestionPriority;
+    category?: string;
+    linkedBeliefId?: string;
+    linkedWorktreeId?: string;
+    answer?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+}>;
+export declare function updateQuestionStatus(deps: QuestionsPort, input: {
+    id: string;
+    status: string;
+    rationale?: string;
+}): Promise<{
+    previousStatus: QuestionStatus;
+    newStatus: QuestionStatus;
+    id: string;
+    nodeId: string;
+    questionId: string;
+    globalId?: string;
+    topicId?: string;
+    text: string;
+    status: QuestionStatus;
+    priority: QuestionPriority;
+    category?: string;
+    linkedBeliefId?: string;
+    linkedWorktreeId?: string;
+    answer?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    metadata?: Record<string, unknown>;
+}>;
+export declare function archiveQuestion(deps: QuestionsPort, input: {
+    id: string;
+    rationale?: string;
+}): Promise<QuestionArchiveResult>;
+export declare function answerQuestion(deps: QuestionsPort, input: {
+    id: string;
+    text: string;
+    confidence?: string;
+    evidenceIds?: string[];
+    rationale?: string;
+}): Promise<QuestionAnswerResult>;
+export {};

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

@@ -0,0 +1,97 @@
+type SearchResourceType = "belief" | "evidence" | "question";
+type SearchBeliefRecord = {
+    beliefId?: string;
+    nodeId?: string;
+    globalId?: string;
+    text?: string;
+    canonicalText?: string;
+    confidence?: number | null;
+    status?: string;
+};
+type SearchEvidenceRecord = {
+    evidenceId?: string;
+    nodeId?: string;
+    globalId?: string;
+    text?: string;
+    source?: string;
+    kind?: string;
+    relevanceScore?: number;
+};
+type SearchQuestionRecord = {
+    questionId?: string;
+    nodeId?: string;
+    globalId?: string;
+    text?: string;
+    status?: string;
+    priority?: string;
+    linkedBeliefId?: string;
+};
+export type SearchInput = {
+    q: string;
+    topicId: string;
+    types?: SearchResourceType[];
+    status?: string;
+    minConfidence?: number;
+    limit?: number;
+    cursor?: string;
+};
+export type SearchBeliefHit = {
+    type: "belief";
+    beliefId: string;
+    nodeId: string;
+    globalId?: string;
+    text: string;
+    confidence: number | null;
+    status?: string;
+    relevanceScore: number;
+};
+export type SearchEvidenceHit = {
+    type: "evidence";
+    evidenceId: string;
+    nodeId: string;
+    globalId?: string;
+    text: string;
+    source?: string;
+    kind?: string;
+    relevanceScore: number;
+};
+export type SearchQuestionHit = {
+    type: "question";
+    questionId: string;
+    nodeId: string;
+    globalId?: string;
+    text: string;
+    status?: string;
+    priority?: string;
+    linkedBeliefId?: string;
+    relevanceScore: number;
+};
+export type SearchResult = SearchBeliefHit | SearchEvidenceHit | SearchQuestionHit;
+export type SearchResponse = {
+    q: string;
+    topicId: string;
+    types: SearchResourceType[];
+    results: SearchResult[];
+    beliefs: SearchBeliefHit[];
+    evidence: SearchEvidenceHit[];
+    questions: SearchQuestionHit[];
+};
+export type SearchPort = {
+    listBeliefs: (input: {
+        topicId: string;
+        status?: string;
+        minConfidence?: number;
+        limit?: number;
+    }) => Promise<SearchBeliefRecord[]>;
+    searchEvidence: (input: {
+        q: string;
+        topicId: string;
+        limit?: number;
+    }) => Promise<SearchEvidenceRecord[]>;
+    listQuestions: (input: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<SearchQuestionRecord[]>;
+};
+export declare function searchResources(deps: SearchPort, input: SearchInput): Promise<SearchResponse>;
+export {};

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

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