chattercatcher 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,808 @@
+import { z } from 'zod';
+import Database from 'better-sqlite3';
+import * as lark from '@larksuiteoapi/node-sdk';
+import { FastifyInstance } from 'fastify';
+
+declare const appConfigSchema: z.ZodObject<{
+    feishu: z.ZodObject<{
+        domain: z.ZodDefault<z.ZodEnum<{
+            feishu: "feishu";
+            lark: "lark";
+        }>>;
+        appId: z.ZodDefault<z.ZodString>;
+        groupPolicy: z.ZodDefault<z.ZodEnum<{
+            open: "open";
+            allowlist: "allowlist";
+            disabled: "disabled";
+        }>>;
+        requireMention: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    llm: z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>;
+        model: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    embedding: z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>;
+        model: z.ZodDefault<z.ZodString>;
+        dimension: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    storage: z.ZodObject<{
+        dataDir: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    web: z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    schedules: z.ZodObject<{
+        indexing: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const appSecretsSchema: z.ZodObject<{
+    feishu: z.ZodObject<{
+        appSecret: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    llm: z.ZodObject<{
+        apiKey: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    embedding: z.ZodObject<{
+        apiKey: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type AppConfig = z.infer<typeof appConfigSchema>;
+type AppSecrets = z.infer<typeof appSecretsSchema>;
+declare function createDefaultConfig(): AppConfig;
+declare function createDefaultSecrets(): AppSecrets;
+
+declare function loadConfig(): Promise<AppConfig>;
+declare function saveConfig(config: AppConfig): Promise<void>;
+declare function loadSecrets(): Promise<AppSecrets>;
+declare function saveSecrets(secrets: AppSecrets): Promise<void>;
+declare function ensureConfigFiles(): Promise<{
+    config: AppConfig;
+    secrets: AppSecrets;
+}>;
+declare function resetConfigFiles(): Promise<void>;
+declare function maskSecret(value: string): string;
+
+declare function applySecretInput(currentValue: string, nextValue: string | undefined): string;
+declare function resolveEmbeddingApiKey(input: {
+    currentEmbeddingKey: string;
+    nextEmbeddingKey?: string;
+    llmApiKey: string;
+}): string;
+
+type SqliteDatabase = Database.Database;
+declare function getDatabasePath(config: AppConfig): string;
+declare function openDatabase(config: AppConfig): SqliteDatabase;
+declare function migrateDatabase(database: SqliteDatabase): void;
+
+type DeleteTargetType = "message" | "chat" | "file";
+interface DeleteLocalDataResult {
+    targetType: DeleteTargetType;
+    targetId: string;
+    deletedMessages: number;
+    deletedChunks: number;
+    deletedFileJobs: number;
+    deletedChats: number;
+    deletedStoredFiles: string[];
+    skippedStoredFiles: string[];
+}
+declare function deleteLocalData(input: {
+    config: AppConfig;
+    database: SqliteDatabase;
+    targetType: DeleteTargetType;
+    targetId: string;
+}): Promise<DeleteLocalDataResult>;
+
+type DoctorStatus = "pass" | "warn" | "fail";
+interface DoctorCheck {
+    name: string;
+    status: DoctorStatus;
+    message: string;
+}
+interface DoctorOptions {
+    online?: boolean;
+}
+declare function runDoctor(config: AppConfig, secrets: AppSecrets, options?: DoctorOptions): Promise<DoctorCheck[]>;
+declare function formatDoctorChecks(checks: DoctorCheck[]): string;
+
+interface DataExportResult {
+    outputPath: string;
+    chats: number;
+    messages: number;
+    chunks: number;
+    fileJobs: number;
+}
+declare function exportLocalData(input: {
+    config: AppConfig;
+    database: SqliteDatabase;
+    outputPath?: string;
+    exportedAt?: string;
+}): Promise<DataExportResult>;
+
+interface DataRestoreResult {
+    inputPath: string;
+    mode: "merge" | "replace";
+    chats: number;
+    messages: number;
+    chunks: number;
+    fileJobs: number;
+}
+declare function restoreLocalData(input: {
+    database: SqliteDatabase;
+    inputPath: string;
+    replace?: boolean;
+}): Promise<DataRestoreResult>;
+
+interface ChatRecord {
+    id: string;
+    platform: string;
+    platformChatId: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface MessageRecord {
+    id: string;
+    platform: string;
+    platformMessageId: string;
+    chatId: string;
+    senderId: string;
+    senderName: string;
+    messageType: string;
+    text: string;
+    rawPayloadJson: string;
+    sentAt: string;
+    receivedAt: string;
+    createdAt: string;
+}
+interface FileRecord {
+    messageId: string;
+    fileName: string;
+    sourcePath?: string;
+    storedPath?: string;
+    bytes?: number;
+    characters: number;
+    parser?: string;
+    parserWarnings?: string[];
+    importedAt: string;
+}
+interface IngestMessageInput {
+    platform: string;
+    platformChatId: string;
+    chatName: string;
+    platformMessageId: string;
+    senderId: string;
+    senderName: string;
+    messageType: string;
+    text: string;
+    rawPayload?: unknown;
+    sentAt: string;
+}
+interface MessageSearchResult {
+    chunkId: string;
+    messageId: string;
+    platform: string;
+    text: string;
+    score: number;
+    messageType: string;
+    chatName: string;
+    senderName: string;
+    sentAt: string;
+}
+
+type JsonObject = Record<string, unknown>;
+interface FeishuAttachmentMetadata {
+    platform: "feishu";
+    kind: "file" | "image" | "audio" | "media";
+    fileKey: string;
+    fileName?: string;
+    mimeType?: string;
+    size?: number;
+}
+interface FeishuReceiveMessageEvent {
+    event?: {
+        sender?: {
+            sender_id?: {
+                open_id?: string;
+                user_id?: string;
+                union_id?: string;
+            };
+        };
+        message?: {
+            message_id?: string;
+            chat_id?: string;
+            chat_type?: string;
+            create_time?: string;
+            message_type?: string;
+            content?: string;
+            mentions?: Array<{
+                name?: string;
+                key?: string;
+                id?: {
+                    open_id?: string;
+                    user_id?: string;
+                    union_id?: string;
+                };
+            }>;
+        };
+    };
+}
+declare function extractFeishuAttachment(messageType: string, content: JsonObject): FeishuAttachmentMetadata | undefined;
+declare function normalizeFeishuReceiveMessageEvent(payload: FeishuReceiveMessageEvent): IngestMessageInput | null;
+
+interface DownloadResponseLike {
+    writeFile(filePath: string): Promise<unknown>;
+}
+interface FeishuResourceClientLike {
+    im: {
+        v1?: {
+            messageResource?: {
+                get(payload: {
+                    params: {
+                        type: string;
+                    };
+                    path: {
+                        message_id: string;
+                        file_key: string;
+                    };
+                }): Promise<DownloadResponseLike>;
+            };
+        };
+        messageResource?: {
+            get(payload: {
+                params: {
+                    type: string;
+                };
+                path: {
+                    message_id: string;
+                    file_key: string;
+                };
+            }): Promise<DownloadResponseLike>;
+        };
+    };
+}
+interface FeishuDownloadResourceInput {
+    messageId: string;
+    attachment: FeishuAttachmentMetadata;
+}
+interface FeishuDownloadedResource {
+    messageId: string;
+    fileKey: string;
+    fileName: string;
+    resourceType: string;
+    storedPath: string;
+}
+declare class FeishuResourceDownloader {
+    private readonly client;
+    private readonly dataDir;
+    constructor(client: FeishuResourceClientLike, dataDir: string);
+    static fromConfig(config: AppConfig, secrets: AppSecrets): FeishuResourceDownloader;
+    download(input: FeishuDownloadResourceInput): Promise<FeishuDownloadedResource>;
+}
+
+declare class MessageRepository {
+    private readonly database;
+    constructor(database: SqliteDatabase);
+    ingest(input: IngestMessageInput): string;
+    listRecentMessages(limit?: number): MessageSearchResult[];
+    listAllMessageChunks(limit?: number): MessageSearchResult[];
+    listMessageChunksByMessageIds(messageIds: string[], limit?: number): MessageSearchResult[];
+    searchMessages(query: string, limit?: number, options?: {
+        excludeMessageIds?: string[];
+    }): MessageSearchResult[];
+    getChatCount(): number;
+    getMessageCount(): number;
+    hasPlatformMessage(platform: string, platformMessageId: string): boolean;
+    listChats(): ChatRecord[];
+    listFiles(limit?: number): FileRecord[];
+}
+
+type FileJobStatus = "processing" | "indexed" | "failed";
+interface FileJobRecord {
+    id: string;
+    sourcePath: string;
+    storedPath?: string;
+    fileName: string;
+    status: FileJobStatus;
+    parser?: string;
+    messageId?: string;
+    bytes?: number;
+    characters?: number;
+    warnings: string[];
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+declare class FileJobRepository {
+    private readonly database;
+    constructor(database: SqliteDatabase);
+    start(input: {
+        sourcePath: string;
+        fileName?: string;
+    }): string;
+    complete(input: {
+        id: string;
+        storedPath: string;
+        parser: string;
+        messageId: string;
+        bytes: number;
+        characters: number;
+        warnings: string[];
+    }): void;
+    fail(input: {
+        id: string;
+        error: string;
+    }): void;
+    get(id: string): FileJobRecord | null;
+    list(limit?: number, options?: {
+        status?: FileJobStatus;
+    }): FileJobRecord[];
+    private listByWhere;
+}
+
+interface IngestLocalFileResult {
+    messageId: string;
+    sourcePath: string;
+    storedPath: string;
+    fileName: string;
+    bytes: number;
+    characters: number;
+    parser: string;
+    warnings: string[];
+    jobId?: string;
+}
+declare function isSupportedTextFile(filePath: string): boolean;
+declare function ingestLocalFile(input: {
+    config: AppConfig;
+    messages: MessageRepository;
+    filePath: string;
+    jobs?: FileJobRepository;
+}): Promise<IngestLocalFileResult>;
+
+interface GatewayIngestResult {
+    accepted: boolean;
+    messageId?: string;
+    message?: IngestMessageInput;
+    duplicate?: boolean;
+    reason?: string;
+}
+interface GatewayAttachmentIngestResult {
+    downloaded?: FeishuDownloadedResource;
+    indexedMessageId?: string;
+    vectorIndexed?: {
+        chunks: number;
+        vectors: number;
+    };
+    skippedReason?: string;
+}
+interface GatewayIngestAndDownloadResult extends GatewayIngestResult {
+    attachment?: GatewayAttachmentIngestResult;
+}
+declare class GatewayIngestor {
+    private readonly messages;
+    private readonly jobs;
+    constructor(database: SqliteDatabase);
+    ingestFeishuEvent(payload: FeishuReceiveMessageEvent): GatewayIngestResult;
+    ingestFeishuEventAndDownloadAttachments(input: {
+        payload: FeishuReceiveMessageEvent;
+        downloader: FeishuResourceDownloader;
+        config: Parameters<typeof ingestLocalFile>[0]["config"];
+        vectorIndexMessage?: (messageId: string) => Promise<{
+            chunks: number;
+            vectors: number;
+        }>;
+    }): Promise<GatewayIngestAndDownloadResult>;
+}
+
+type SourceType = "message" | "file" | "image" | "audio" | "link" | "feishu_doc";
+interface EvidenceSource {
+    type: SourceType;
+    label: string;
+    timestamp?: string;
+    sender?: string;
+    location?: string;
+}
+interface EvidenceBlock {
+    id: string;
+    text: string;
+    score: number;
+    source: EvidenceSource;
+}
+interface Citation {
+    marker: string;
+    evidenceId: string;
+    source: EvidenceSource;
+    text: string;
+}
+interface GroundedAnswer {
+    answer: string;
+    citations: Citation[];
+}
+interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+interface ChatModel {
+    complete(messages: ChatMessage[]): Promise<string>;
+}
+
+interface MessageSender {
+    sendTextToChat(chatId: string, text: string): Promise<void>;
+    replyTextToMessage?(messageId: string, text: string): Promise<void>;
+    addReactionToMessage?(messageId: string, emojiType: string): Promise<void>;
+}
+interface FeishuClientLike {
+    im: {
+        v1?: {
+            message: {
+                create(payload: {
+                    data: {
+                        receive_id: string;
+                        msg_type: string;
+                        content: string;
+                    };
+                    params: {
+                        receive_id_type: "chat_id";
+                    };
+                }): Promise<unknown>;
+                reply?: (payload: {
+                    path: {
+                        message_id: string;
+                    };
+                    data: {
+                        msg_type: string;
+                        content: string;
+                    };
+                }) => Promise<unknown>;
+            };
+            messageReaction?: {
+                create(payload: {
+                    path: {
+                        message_id: string;
+                    };
+                    data: {
+                        reaction_type: {
+                            emoji_type: string;
+                        };
+                    };
+                }): Promise<unknown>;
+            };
+        };
+        message?: {
+            create(payload: {
+                data: {
+                    receive_id: string;
+                    msg_type: string;
+                    content: string;
+                };
+                params: {
+                    receive_id_type: "chat_id";
+                };
+            }): Promise<unknown>;
+            reply?: (payload: {
+                path: {
+                    message_id: string;
+                };
+                data: {
+                    msg_type: string;
+                    content: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+}
+declare function mapDomain(domain: AppConfig["feishu"]["domain"]): lark.Domain;
+declare class FeishuMessageSender implements MessageSender {
+    private readonly client;
+    constructor(client: FeishuClientLike);
+    static fromConfig(config: AppConfig, secrets: AppSecrets): FeishuMessageSender;
+    sendTextToChat(chatId: string, text: string): Promise<void>;
+    replyTextToMessage(messageId: string, text: string): Promise<void>;
+    addReactionToMessage(messageId: string, emojiType: string): Promise<void>;
+}
+
+interface FeishuQuestionHandlerOptions {
+    config: AppConfig;
+    secrets: AppSecrets;
+    database: SqliteDatabase;
+    model: ChatModel;
+    sender: MessageSender;
+    thinkingEmojiType?: string;
+}
+interface FeishuQuestionDecision {
+    shouldAnswer: boolean;
+    question?: string;
+    chatId?: string;
+    reason?: string;
+}
+declare function isFeishuMessageAddressedToBot(payload: FeishuReceiveMessageEvent): boolean;
+declare function getFeishuQuestionDecision(payload: FeishuReceiveMessageEvent, config: AppConfig): FeishuQuestionDecision;
+declare class FeishuQuestionHandler {
+    private readonly options;
+    constructor(options: FeishuQuestionHandlerOptions);
+    private sendResponse;
+    private acknowledgeQuestion;
+    handle(payload: FeishuReceiveMessageEvent, options?: {
+        excludeMessageIds?: string[];
+    }): Promise<FeishuQuestionDecision>;
+}
+
+interface FeishuGatewayRuntime {
+    start(): Promise<void>;
+    stop(): void;
+}
+interface WsClientLike {
+    start(params: {
+        eventDispatcher: lark.EventDispatcher;
+    }): Promise<void>;
+    close(params?: {
+        force?: boolean;
+    }): void;
+}
+interface FeishuGatewayOptions {
+    config: AppConfig;
+    secrets: AppSecrets;
+    ingestor: GatewayIngestor;
+    questionHandler?: FeishuQuestionHandler;
+    resourceDownloader?: FeishuResourceDownloader;
+    attachmentVectorIndexer?: (messageId: string) => Promise<{
+        chunks: number;
+        vectors: number;
+    }>;
+    wsClientFactory?: (params: {
+        appId: string;
+        appSecret: string;
+        domain: lark.Domain;
+        onReady: () => void;
+        onError: (error: Error) => void;
+        onReconnecting: () => void;
+        onReconnected: () => void;
+    }) => WsClientLike;
+}
+declare function createFeishuEventDispatcher(options: {
+    config: AppConfig;
+    ingestor: GatewayIngestor;
+    questionHandler?: FeishuQuestionHandler;
+    resourceDownloader?: FeishuResourceDownloader;
+    attachmentVectorIndexer?: (messageId: string) => Promise<{
+        chunks: number;
+        vectors: number;
+    }>;
+}): lark.EventDispatcher;
+declare function createFeishuGateway(options: FeishuGatewayOptions): FeishuGatewayRuntime;
+
+interface ParsedFile {
+    text: string;
+    parser: "text" | "docx" | "pdf";
+    warnings: string[];
+}
+declare function isSupportedParseFile(filePath: string): boolean;
+declare function describeSupportedParseTypes(): string;
+declare function parseFileToText(filePath: string): Promise<ParsedFile>;
+
+interface GatewayPidRecord {
+    pid: number;
+    startedAt: string;
+    command: string;
+}
+interface GatewayRuntimeState {
+    pidFile: string;
+    record: GatewayPidRecord | null;
+    running: boolean;
+    stale: boolean;
+}
+interface StopGatewayResult {
+    stopped: boolean;
+    message: string;
+}
+declare function getGatewayPidPath(): string;
+declare function isProcessRunning(pid: number): boolean;
+declare function readGatewayPidRecord(pidFile?: string): GatewayPidRecord | null;
+declare function writeGatewayPidRecord(pidFile?: string, record?: GatewayPidRecord): void;
+declare function removeGatewayPidRecord(pidFile?: string): void;
+declare function getGatewayRuntimeState(pidFile?: string): GatewayRuntimeState;
+declare function stopGatewayProcess(pidFile?: string): StopGatewayResult;
+
+interface EmbeddingModel {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+declare function cosineSimilarity(left: number[], right: number[]): number;
+
+interface OpenAICompatibleChatOptions {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    temperature?: number;
+}
+declare class OpenAICompatibleChatModel implements ChatModel {
+    private readonly options;
+    constructor(options: OpenAICompatibleChatOptions);
+    complete(messages: ChatMessage[]): Promise<string>;
+}
+interface OpenAICompatibleEmbeddingOptions {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+}
+declare class OpenAICompatibleEmbeddingModel implements EmbeddingModel {
+    private readonly options;
+    constructor(options: OpenAICompatibleEmbeddingOptions);
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+declare function createChatModel(config: AppConfig, secrets: AppSecrets): OpenAICompatibleChatModel;
+declare function createEmbeddingModel(config: AppConfig, secrets: AppSecrets): OpenAICompatibleEmbeddingModel;
+
+interface LogFileInfo {
+    name: string;
+    path: string;
+    updatedAt: Date;
+    bytes: number;
+}
+interface LogTailResult {
+    file: LogFileInfo;
+    content: string;
+}
+declare function getLogsDirectory(): string;
+declare function resolveLogPath(fileName: string, logsDir?: string): string;
+declare function normalizeLineCount(value: number | string | undefined, fallback?: number): number;
+declare function listLogFiles(logsDir?: string): Promise<LogFileInfo[]>;
+declare function readLogTail(input: {
+    filePath: string;
+    lines?: number;
+}): Promise<LogTailResult>;
+declare function readLatestLogTail(input?: {
+    fileName?: string;
+    lines?: number;
+    logsDir?: string;
+}): Promise<LogTailResult | null>;
+declare function followLogFile(input: {
+    filePath: string;
+    onChunk: (chunk: string) => void;
+    onError?: (error: Error) => void;
+}): Promise<() => void>;
+
+interface TextChunk {
+    index: number;
+    text: string;
+}
+declare function chunkText(text: string, maxChars?: number, overlapChars?: number): TextChunk[];
+
+interface BuildEvidencePromptOptions {
+    maxEvidenceBlocks?: number;
+    maxCharsPerBlock?: number;
+}
+interface EvidencePrompt {
+    messages: ChatMessage[];
+    citations: Citation[];
+}
+declare function rankEvidenceForPrompt(evidence: EvidenceBlock[]): EvidenceBlock[];
+declare function buildEvidencePrompt(question: string, evidence: EvidenceBlock[], options?: BuildEvidencePromptOptions): EvidencePrompt;
+declare function generateGroundedAnswer(input: {
+    question: string;
+    evidence: EvidenceBlock[];
+    model: ChatModel;
+}): Promise<GroundedAnswer>;
+
+declare function formatCitation(citation: Citation, options?: {
+    maxTextLength?: number;
+}): string;
+declare function formatCitations(citations: Citation[], options?: {
+    maxTextLength?: number;
+}): string;
+
+interface Retriever {
+    retrieve(question: string): Promise<EvidenceBlock[]>;
+}
+
+interface HybridRetrieverOptions {
+    limit?: number;
+}
+declare class HybridRetriever implements Retriever {
+    private readonly retrievers;
+    private readonly options;
+    constructor(retrievers: Retriever[], options?: HybridRetrieverOptions);
+    retrieve(question: string): Promise<EvidenceBlock[]>;
+}
+
+interface VectorRecord {
+    id: string;
+    vector: number[];
+    evidence: EvidenceBlock;
+}
+interface VectorSearchResult extends EvidenceBlock {
+    vectorScore: number;
+}
+interface VectorStore {
+    upsert(records: VectorRecord[]): Promise<void>;
+    search(vector: number[], limit: number): Promise<VectorSearchResult[]>;
+}
+declare class MemoryVectorStore implements VectorStore {
+    private readonly records;
+    upsert(records: VectorRecord[]): Promise<void>;
+    search(vector: number[], limit: number): Promise<VectorSearchResult[]>;
+}
+
+interface VectorIndexStats {
+    chunks: number;
+    vectors: number;
+}
+declare function indexMessageChunks(input: {
+    messages: MessageRepository;
+    embedding: EmbeddingModel;
+    store: VectorStore;
+    limit?: number;
+    messageIds?: string[];
+}): Promise<VectorIndexStats>;
+
+declare function getLanceDbPath(config: AppConfig): string;
+declare class LanceDbVectorStore implements VectorStore {
+    private readonly connection;
+    private readonly tableName;
+    private constructor();
+    static connect(uri: string, tableName?: string): Promise<LanceDbVectorStore>;
+    static connectFromConfig(config: AppConfig, tableName?: string): Promise<LanceDbVectorStore>;
+    close(): void;
+    upsert(records: VectorRecord[]): Promise<void>;
+    search(vector: number[], limit: number): Promise<VectorSearchResult[]>;
+    count(): Promise<number>;
+    private ensureTable;
+    private openTableIfExists;
+}
+
+declare function hasEmbeddingConfig(config: AppConfig, secrets: AppSecrets): boolean;
+declare function createHybridRetriever(input: {
+    config: AppConfig;
+    secrets: AppSecrets;
+    messages: MessageRepository;
+    excludeMessageIds?: string[];
+}): Promise<{
+    retriever: Retriever;
+    close: () => void;
+}>;
+
+interface ManualMessageIndexResult {
+    status: "completed" | "skipped";
+    reason?: string;
+    chunks: number;
+    vectors: number;
+    startedAt: string;
+    finishedAt: string;
+}
+declare function processMessagesNow(input: {
+    config: AppConfig;
+    secrets: AppSecrets;
+    database: SqliteDatabase;
+    limit?: number;
+}): Promise<ManualMessageIndexResult>;
+
+declare class MessageFtsRetriever implements Retriever {
+    private readonly messages;
+    private readonly options;
+    constructor(messages: MessageRepository, options?: {
+        excludeMessageIds?: string[];
+    });
+    retrieve(question: string): Promise<EvidenceBlock[]>;
+}
+
+interface AskWithRagInput {
+    question: string;
+    retriever: Retriever;
+    model: ChatModel;
+}
+declare function askWithRag(input: AskWithRagInput): Promise<GroundedAnswer>;
+
+declare class VectorRetriever implements Retriever {
+    private readonly embedding;
+    private readonly store;
+    private readonly limit;
+    constructor(embedding: EmbeddingModel, store: VectorStore, limit?: number);
+    retrieve(question: string): Promise<EvidenceBlock[]>;
+}
+
+declare function createWebApp(config: AppConfig): FastifyInstance;
+declare function startWebServer(config: AppConfig): Promise<void>;
+
+export { type AppConfig, type AppSecrets, type AskWithRagInput, type BuildEvidencePromptOptions, type ChatMessage, type ChatModel, type ChatRecord, type Citation, type DataExportResult, type DataRestoreResult, type DeleteLocalDataResult, type DeleteTargetType, type DoctorCheck, type DoctorOptions, type DoctorStatus, type EmbeddingModel, type EvidenceBlock, type EvidencePrompt, type EvidenceSource, type FeishuAttachmentMetadata, type FeishuDownloadResourceInput, type FeishuDownloadedResource, type FeishuGatewayOptions, type FeishuGatewayRuntime, FeishuMessageSender, type FeishuQuestionDecision, FeishuQuestionHandler, type FeishuQuestionHandlerOptions, type FeishuReceiveMessageEvent, FeishuResourceDownloader, type FileJobRecord, FileJobRepository, type FileJobStatus, type FileRecord, type GatewayAttachmentIngestResult, type GatewayIngestAndDownloadResult, type GatewayIngestResult, GatewayIngestor, type GatewayPidRecord, type GatewayRuntimeState, type GroundedAnswer, HybridRetriever, type HybridRetrieverOptions, type IngestLocalFileResult, type IngestMessageInput, LanceDbVectorStore, type LogFileInfo, type LogTailResult, type ManualMessageIndexResult, MemoryVectorStore, MessageFtsRetriever, type MessageRecord, MessageRepository, type MessageSearchResult, type MessageSender, OpenAICompatibleChatModel, type OpenAICompatibleChatOptions, OpenAICompatibleEmbeddingModel, type OpenAICompatibleEmbeddingOptions, type ParsedFile, type SourceType, type SqliteDatabase, type StopGatewayResult, type TextChunk, type VectorIndexStats, type VectorRecord, VectorRetriever, type VectorSearchResult, type VectorStore, appConfigSchema, appSecretsSchema, applySecretInput, askWithRag, buildEvidencePrompt, chunkText, cosineSimilarity, createChatModel, createDefaultConfig, createDefaultSecrets, createEmbeddingModel, createFeishuEventDispatcher, createFeishuGateway, createHybridRetriever, createWebApp, deleteLocalData, describeSupportedParseTypes, ensureConfigFiles, exportLocalData, extractFeishuAttachment, followLogFile, formatCitation, formatCitations, formatDoctorChecks, generateGroundedAnswer, getDatabasePath, getFeishuQuestionDecision, getGatewayPidPath, getGatewayRuntimeState, getLanceDbPath, getLogsDirectory, hasEmbeddingConfig, indexMessageChunks, ingestLocalFile, isFeishuMessageAddressedToBot, isProcessRunning, isSupportedParseFile, isSupportedTextFile, listLogFiles, loadConfig, loadSecrets, mapDomain, maskSecret, migrateDatabase, normalizeFeishuReceiveMessageEvent, normalizeLineCount, openDatabase, parseFileToText, processMessagesNow, rankEvidenceForPrompt, readGatewayPidRecord, readLatestLogTail, readLogTail, removeGatewayPidRecord, resetConfigFiles, resolveEmbeddingApiKey, resolveLogPath, restoreLocalData, runDoctor, saveConfig, saveSecrets, startWebServer, stopGatewayProcess, writeGatewayPidRecord };