@lucern/sdk 0.2.0-alpha.1

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

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

@@ -0,0 +1,102 @@
+type TaskStatus = "todo" | "in_progress" | "blocked" | "done";
+type TaskPriority = "low" | "medium" | "high" | "urgent";
+type TaskType = "research" | "interview" | "analysis" | "data_collection" | "general";
+export type TaskRecord = {
+    id: string;
+    taskId: string;
+    topicId?: string;
+    title: string;
+    description?: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    taskType: TaskType;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    outputSummary?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    completedAt?: number;
+    metadata?: Record<string, unknown>;
+};
+export type TaskListResult = {
+    tasks: TaskRecord[];
+    count: number;
+};
+export type CreateTaskInput = {
+    topicId: string;
+    title: string;
+    description?: string;
+    taskType?: string;
+    priority?: string;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type UpdateTaskInput = {
+    id: string;
+    title?: string;
+    description?: string;
+    priority?: string;
+    status?: string;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type CompleteTaskInput = {
+    id: string;
+    outputSummary?: string;
+};
+export type ListTasksQuery = {
+    topicId?: string;
+    worktreeId?: string;
+    status?: string;
+    limit?: number;
+};
+type TaskCreatePortInput = {
+    topicId: string;
+    title: string;
+    description?: string;
+    taskType: TaskType;
+    priority: TaskPriority;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+type TaskUpdatePortInput = {
+    taskRawId: string;
+    title?: string;
+    description?: string;
+    priority?: TaskPriority;
+    status?: TaskStatus;
+    linkedBeliefId?: string;
+    linkedQuestionId?: string;
+    linkedWorktreeId?: string;
+    metadata?: Record<string, unknown>;
+};
+type TaskCompletePortInput = {
+    taskRawId: string;
+    outputSummary?: string;
+};
+export type TasksPort = {
+    fetchTask: (rawId: string) => Promise<unknown | null>;
+    listTasksByTopic: (args: {
+        topicId: string;
+        status?: TaskStatus;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listTasksByWorktree: (args: {
+        worktreeId: string;
+    }) => Promise<unknown[]>;
+    createTask: (input: TaskCreatePortInput) => Promise<unknown>;
+    updateTask: (input: TaskUpdatePortInput) => Promise<unknown>;
+    completeTask: (input: TaskCompletePortInput) => Promise<unknown>;
+};
+export declare function createTask(deps: TasksPort, input: CreateTaskInput): Promise<TaskRecord>;
+export declare function updateTask(deps: TasksPort, input: UpdateTaskInput): Promise<TaskRecord>;
+export declare function completeTask(deps: TasksPort, input: CompleteTaskInput): Promise<TaskRecord>;
+export declare function listTasks(deps: TasksPort, query: ListTasksQuery): Promise<TaskListResult>;
+export {};

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

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

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

@@ -0,0 +1,147 @@
+type TopicStatus = "active" | "archived" | "watching";
+type TopicVisibility = "private" | "team" | "firm" | "external" | "public";
+type TopicCoverageState = "full" | "partial" | "empty";
+export type TopicRecord = {
+    id: string;
+    topicId: string;
+    globalId?: string;
+    name: string;
+    description?: string;
+    type: string;
+    depth?: number;
+    status?: TopicStatus;
+    parentTopicId?: string | null;
+    tenantId?: string;
+    workspaceId?: string;
+    visibility?: TopicVisibility;
+    createdAt?: number;
+    updatedAt?: number;
+};
+export type TopicListResult = {
+    topics: TopicRecord[];
+    total: number;
+};
+export type TopicTreeNode = TopicRecord & {
+    path?: string[];
+};
+export type TopicTreeResult = {
+    tree: TopicTreeNode[];
+};
+export type TopicCoverageRecord = {
+    topicId: string;
+    name: string;
+    type: string;
+    depth: number;
+    beliefs: number;
+    questions: number;
+    evidence: number;
+    coverage: TopicCoverageState;
+};
+export type TopicCoverageSummary = {
+    totalTopics: number;
+    coveredTopics: number;
+    emptyTopics: number;
+    coveragePercent: number;
+    totalBeliefs: number;
+    totalQuestions: number;
+    totalEvidence: number;
+};
+export type TopicCoverageResult = {
+    topics: TopicCoverageRecord[];
+    summary: TopicCoverageSummary;
+    scopeTopicId?: string | null;
+};
+export type CreateTopicInput = {
+    name: string;
+    description?: string;
+    type?: string;
+    parentTopicId?: string;
+    ontologyId?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    visibility?: TopicVisibility;
+    createdBy?: string;
+};
+export type UpdateTopicInput = {
+    id: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    ontologyId?: string;
+    clearOntologyId?: boolean;
+    status?: TopicStatus;
+    visibility?: TopicVisibility;
+};
+export type GetTopicInput = {
+    id: string;
+};
+export type ListTopicsQuery = {
+    ontologyId?: string;
+    parentTopicId?: string;
+    status?: TopicStatus | string;
+    type?: string;
+};
+export type GetTopicTreeInput = {
+    id: string;
+    maxDepth?: number;
+};
+export type GetTopicCoverageInput = {
+    id: string;
+    includeDescendants?: boolean;
+    maxDepth?: number;
+};
+type CreateTopicPortInput = {
+    name: string;
+    description?: string;
+    type: string;
+    parentTopicRawId?: string;
+    ontologyId?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    visibility?: TopicVisibility;
+    createdBy?: string;
+};
+type UpdateTopicPortInput = {
+    topicRawId: string;
+    name?: string;
+    description?: string;
+    type?: string;
+    ontologyId?: string;
+    clearOntologyId?: boolean;
+    status?: TopicStatus;
+    visibility?: TopicVisibility;
+};
+export type TopicsPort = {
+    fetchTopic: (rawId: string) => Promise<unknown | null>;
+    listTopics: (query: {
+        ontologyId?: string;
+        parentTopicRawId?: string;
+        status?: string;
+        type?: string;
+    }) => Promise<unknown[]>;
+    createTopic: (input: CreateTopicPortInput) => Promise<unknown>;
+    updateTopic?: (input: UpdateTopicPortInput) => Promise<unknown>;
+    fetchTopicTree: (args: {
+        rootRawId: string;
+        maxDepth?: number;
+    }) => Promise<unknown>;
+    listBeliefsByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listQuestionsByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+    listEvidenceByTopic: (args: {
+        topicId: string;
+        limit?: number;
+    }) => Promise<unknown[]>;
+};
+export declare function createTopic(deps: TopicsPort, input: CreateTopicInput): Promise<TopicRecord>;
+export declare function updateTopic(deps: TopicsPort, input: UpdateTopicInput): Promise<TopicRecord>;
+export declare function getTopic(deps: TopicsPort, input: GetTopicInput): Promise<TopicRecord>;
+export declare function listTopics(deps: TopicsPort, query?: ListTopicsQuery): Promise<TopicListResult>;
+export declare function getTopicTree(deps: TopicsPort, input: GetTopicTreeInput): Promise<TopicTreeResult>;
+export declare function getTopicCoverage(deps: TopicsPort, input: GetTopicCoverageInput): Promise<TopicCoverageResult>;
+export {};

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

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